home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / cpu / m6809 / 6809ops.c < prev    next >
C/C++ Source or Header  |  2000-04-23  |  49KB  |  3,078 lines
  1. /*
  2.  
  3. HNZVC
  4.  
  5. ? = undefined
  6. * = affected
  7. - = unaffected
  8. 0 = cleared
  9. 1 = set
  10. # = CCr directly affected by instruction
  11. @ = special - carry set if bit 7 is set
  12.  
  13. */
  14.  
  15. #ifdef NEW
  16. static void illegal( void )
  17. #else
  18. INLINE void illegal( void )
  19. #endif
  20. {
  21.     logerror("M6809: illegal opcode at %04x\n",PC);
  22. }
  23.  
  24. #if macintosh
  25. #pragma mark ____0x____
  26. #endif
  27.  
  28. /* $00 NEG direct ?**** */
  29. INLINE void neg_di( void )
  30. {
  31.     UINT16 r,t;
  32.     DIRBYTE(t);
  33.     r = -t;
  34.     CLR_NZVC;
  35.     SET_FLAGS8(0,t,r);
  36.     WM(EAD,r);
  37. }
  38.  
  39. /* $01 ILLEGAL */
  40.  
  41. /* $02 ILLEGAL */
  42.  
  43. /* $03 COM direct -**01 */
  44. INLINE void com_di( void )
  45. {
  46.     UINT8 t;
  47.     DIRBYTE(t);
  48.     t = ~t;
  49.     CLR_NZV;
  50.     SET_NZ8(t);
  51.     SEC;
  52.     WM(EAD,t);
  53. }
  54.  
  55. /* $04 LSR direct -0*-* */
  56. INLINE void lsr_di( void )
  57. {
  58.     UINT8 t;
  59.     DIRBYTE(t);
  60.     CLR_NZC;
  61.     CC |= (t & CC_C);
  62.     t >>= 1;
  63.     SET_Z8(t);
  64.     WM(EAD,t);
  65. }
  66.  
  67. /* $05 ILLEGAL */
  68.  
  69. /* $06 ROR direct -**-* */
  70. INLINE void ror_di( void )
  71. {
  72.     UINT8 t,r;
  73.     DIRBYTE(t);
  74.     r= (CC & CC_C) << 7;
  75.     CLR_NZC;
  76.     CC |= (t & CC_C);
  77.     r |= t>>1;
  78.     SET_NZ8(r);
  79.     WM(EAD,r);
  80. }
  81.  
  82. /* $07 ASR direct ?**-* */
  83. INLINE void asr_di( void )
  84. {
  85.     UINT8 t;
  86.     DIRBYTE(t);
  87.     CLR_NZC;
  88.     CC |= (t & CC_C);
  89.     t = (t & 0x80) | (t >> 1);
  90.     SET_NZ8(t);
  91.     WM(EAD,t);
  92. }
  93.  
  94. /* $08 ASL direct ?**** */
  95. INLINE void asl_di( void )
  96. {
  97.     UINT16 t,r;
  98.     DIRBYTE(t);
  99.     r = t << 1;
  100.     CLR_NZVC;
  101.     SET_FLAGS8(t,t,r);
  102.     WM(EAD,r);
  103. }
  104.  
  105. /* $09 ROL direct -**** */
  106. INLINE void rol_di( void )
  107. {
  108.     UINT16 t,r;
  109.     DIRBYTE(t);
  110.     r = (CC & CC_C) | (t << 1);
  111.     CLR_NZVC;
  112.     SET_FLAGS8(t,t,r);
  113.     WM(EAD,r);
  114. }
  115.  
  116. /* $0A DEC direct -***- */
  117. INLINE void dec_di( void )
  118. {
  119.     UINT8 t;
  120.     DIRBYTE(t);
  121.     --t;
  122.     CLR_NZV;
  123.     SET_FLAGS8D(t);
  124.     WM(EAD,t);
  125. }
  126.  
  127. /* $0B ILLEGAL */
  128.  
  129. /* $OC INC direct -***- */
  130. INLINE void inc_di( void )
  131. {
  132.     UINT8 t;
  133.     DIRBYTE(t);
  134.     ++t;
  135.     CLR_NZV;
  136.     SET_FLAGS8I(t);
  137.     WM(EAD,t);
  138. }
  139.  
  140. /* $OD TST direct -**0- */
  141. INLINE void tst_di( void )
  142. {
  143.     UINT8 t;
  144.     DIRBYTE(t);
  145.     CLR_NZV;
  146.     SET_NZ8(t);
  147. }
  148.  
  149. /* $0E JMP direct ----- */
  150. INLINE void jmp_di( void )
  151. {
  152.     DIRECT;
  153.     PCD = EAD;
  154.     CHANGE_PC;
  155. }
  156.  
  157. /* $0F CLR direct -0100 */
  158. INLINE void clr_di( void )
  159. {
  160.     DIRECT;
  161.     WM(EAD,0);
  162.     CLR_NZVC;
  163.     SEZ;
  164. }
  165.  
  166. #if macintosh
  167. #pragma mark ____1x____
  168. #endif
  169.  
  170. /* $10 FLAG */
  171.  
  172. /* $11 FLAG */
  173.  
  174. /* $12 NOP inherent ----- */
  175. INLINE void nop( void )
  176. {
  177.     ;
  178. }
  179.  
  180. /* $13 SYNC inherent ----- */
  181. INLINE void sync( void )
  182. {
  183.     /* SYNC stops processing instructions until an interrupt request happens. */
  184.     /* This doesn't require the corresponding interrupt to be enabled: if it */
  185.     /* is disabled, execution continues with the next instruction. */
  186.     m6809.int_state |= M6809_SYNC;     /* HJB 990227 */
  187.     CHECK_IRQ_LINES;
  188.     /* if M6809_SYNC has not been cleared by CHECK_IRQ_LINES,
  189.      * stop execution until the interrupt lines change. */
  190.     if( m6809.int_state & M6809_SYNC )
  191.         if (m6809_ICount > 0) m6809_ICount = 0;
  192. }
  193.  
  194. /* $14 ILLEGAL */
  195.  
  196. /* $15 ILLEGAL */
  197.  
  198. /* $16 LBRA relative ----- */
  199. INLINE void lbra( void )
  200. {
  201.     IMMWORD(ea);
  202.     PC += EA;
  203.     CHANGE_PC;
  204.  
  205.     if ( EA == 0xfffd )  /* EHC 980508 speed up busy loop */
  206.         if ( m6809_ICount > 0)
  207.             m6809_ICount = 0;
  208. }
  209.  
  210. /* $17 LBSR relative ----- */
  211. INLINE void lbsr( void )
  212. {
  213.     IMMWORD(ea);
  214.     PUSHWORD(pPC);
  215.     PC += EA;
  216.     CHANGE_PC;
  217. }
  218.  
  219. /* $18 ILLEGAL */
  220.  
  221. #if 1
  222. /* $19 DAA inherent (A) -**0* */
  223. INLINE void daa( void )
  224. {
  225.     UINT8 msn, lsn;
  226.     UINT16 t, cf = 0;
  227.     msn = A & 0xf0; lsn = A & 0x0f;
  228.     if( lsn>0x09 || CC & CC_H) cf |= 0x06;
  229.     if( msn>0x80 && lsn>0x09 ) cf |= 0x60;
  230.     if( msn>0x90 || CC & CC_C) cf |= 0x60;
  231.     t = cf + A;
  232.     CLR_NZV; /* keep carry from previous operation */
  233.     SET_NZ8((UINT8)t); SET_C8(t);
  234.     A = t;
  235. }
  236. #else
  237. /* $19 DAA inherent (A) -**0* */
  238. INLINE void daa( void )
  239. {
  240.     UINT16 t;
  241.     t = A;
  242.     if (CC & CC_H) t+=0x06;
  243.     if ((t&0x0f)>9) t+=0x06;        /* ASG -- this code is broken! $66+$99=$FF -> DAA should = $65, we get $05! */
  244.     if (CC & CC_C) t+=0x60;
  245.     if ((t&0xf0)>0x90) t+=0x60;
  246.     if (t&0x100) SEC;
  247.     A = t;
  248. }
  249. #endif
  250.  
  251. /* $1A ORCC immediate ##### */
  252. INLINE void orcc( void )
  253. {
  254.     UINT8 t;
  255.     IMMBYTE(t);
  256.     CC |= t;
  257.     CHECK_IRQ_LINES;    /* HJB 990116 */
  258. }
  259.  
  260. /* $1B ILLEGAL */
  261.  
  262. /* $1C ANDCC immediate ##### */
  263. INLINE void andcc( void )
  264. {
  265.     UINT8 t;
  266.     IMMBYTE(t);
  267.     CC &= t;
  268.     CHECK_IRQ_LINES;    /* HJB 990116 */
  269. }
  270.  
  271. /* $1D SEX inherent -**0- */
  272. INLINE void sex( void )
  273. {
  274.     UINT16 t;
  275.     t = SIGNED(B);
  276.     D = t;
  277.     CLR_NZV;
  278.     SET_NZ16(t);
  279. }
  280.  
  281. /* $1E EXG inherent ----- */
  282. INLINE void exg( void )
  283. {
  284.     UINT16 t1,t2;
  285.     UINT8 tb;
  286.  
  287.     IMMBYTE(tb);
  288.     if( (tb^(tb>>4)) & 0x08 )    /* HJB 990225: mixed 8/16 bit case? */
  289.     {
  290.         /* transfer $ff to both registers */
  291.         t1 = t2 = 0xff;
  292.     }
  293.     else
  294.     {
  295.         switch(tb>>4) {
  296.             case  0: t1 = D;  break;
  297.             case  1: t1 = X;  break;
  298.             case  2: t1 = Y;  break;
  299.             case  3: t1 = U;  break;
  300.             case  4: t1 = S;  break;
  301.             case  5: t1 = PC; break;
  302.             case  8: t1 = A;  break;
  303.             case  9: t1 = B;  break;
  304.             case 10: t1 = CC; break;
  305.             case 11: t1 = DP; break;
  306.             default: t1 = 0xff;
  307.         }
  308.         switch(tb&15) {
  309.             case  0: t2 = D;  break;
  310.             case  1: t2 = X;  break;
  311.             case  2: t2 = Y;  break;
  312.             case  3: t2 = U;  break;
  313.             case  4: t2 = S;  break;
  314.             case  5: t2 = PC; break;
  315.             case  8: t2 = A;  break;
  316.             case  9: t2 = B;  break;
  317.             case 10: t2 = CC; break;
  318.             case 11: t2 = DP; break;
  319.             default: t2 = 0xff;
  320.         }
  321.     }
  322.     switch(tb>>4) {
  323.         case  0: D = t2;  break;
  324.         case  1: X = t2;  break;
  325.         case  2: Y = t2;  break;
  326.         case  3: U = t2;  break;
  327.         case  4: S = t2;  break;
  328.         case  5: PC = t2; CHANGE_PC; break;
  329.         case  8: A = t2;  break;
  330.         case  9: B = t2;  break;
  331.         case 10: CC = t2; break;
  332.         case 11: DP = t2; break;
  333.     }
  334.     switch(tb&15) {
  335.         case  0: D = t1;  break;
  336.         case  1: X = t1;  break;
  337.         case  2: Y = t1;  break;
  338.         case  3: U = t1;  break;
  339.         case  4: S = t1;  break;
  340.         case  5: PC = t1; CHANGE_PC; break;
  341.         case  8: A = t1;  break;
  342.         case  9: B = t1;  break;
  343.         case 10: CC = t1; break;
  344.         case 11: DP = t1; break;
  345.     }
  346. }
  347.  
  348. /* $1F TFR inherent ----- */
  349. INLINE void tfr( void )
  350. {
  351.     UINT8 tb;
  352.     UINT16 t;
  353.  
  354.     IMMBYTE(tb);
  355.     if( (tb^(tb>>4)) & 0x08 )    /* HJB 990225: mixed 8/16 bit case? */
  356.     {
  357.         /* transfer $ff to register */
  358.         t = 0xff;
  359.     }
  360.     else
  361.     {
  362.         switch(tb>>4) {
  363.             case  0: t = D;  break;
  364.             case  1: t = X;  break;
  365.             case  2: t = Y;  break;
  366.             case  3: t = U;  break;
  367.             case  4: t = S;  break;
  368.             case  5: t = PC; break;
  369.             case  8: t = A;  break;
  370.             case  9: t = B;  break;
  371.             case 10: t = CC; break;
  372.             case 11: t = DP; break;
  373.             default: t = 0xff;
  374.         }
  375.     }
  376.     switch(tb&15) {
  377.         case  0: D = t;  break;
  378.         case  1: X = t;  break;
  379.         case  2: Y = t;  break;
  380.         case  3: U = t;  break;
  381.         case  4: S = t;  break;
  382.         case  5: PC = t; CHANGE_PC; break;
  383.         case  8: A = t;  break;
  384.         case  9: B = t;  break;
  385.         case 10: CC = t; break;
  386.         case 11: DP = t; break;
  387.     }
  388. }
  389.  
  390. #if macintosh
  391. #pragma mark ____2x____
  392. #endif
  393.  
  394. /* $20 BRA relative ----- */
  395. INLINE void bra( void )
  396. {
  397.     UINT8 t;
  398.     IMMBYTE(t);
  399.     PC += SIGNED(t);
  400.     CHANGE_PC;
  401.     /* JB 970823 - speed up busy loops */
  402.     if( t == 0xfe )
  403.         if( m6809_ICount > 0 ) m6809_ICount = 0;
  404. }
  405.  
  406. /* $21 BRN relative ----- */
  407. INLINE void brn( void )
  408. {
  409.     UINT8 t;
  410.     IMMBYTE(t);
  411. }
  412.  
  413. /* $1021 LBRN relative ----- */
  414. INLINE void lbrn( void )
  415. {
  416.     IMMWORD(ea);
  417. }
  418.  
  419. /* $22 BHI relative ----- */
  420. INLINE void bhi( void )
  421. {
  422.     BRANCH( !(CC & (CC_Z|CC_C)) );
  423. }
  424.  
  425. /* $1022 LBHI relative ----- */
  426. INLINE void lbhi( void )
  427. {
  428.     LBRANCH( !(CC & (CC_Z|CC_C)) );
  429. }
  430.  
  431. /* $23 BLS relative ----- */
  432. INLINE void bls( void )
  433. {
  434.     BRANCH( (CC & (CC_Z|CC_C)) );
  435. }
  436.  
  437. /* $1023 LBLS relative ----- */
  438. INLINE void lbls( void )
  439. {
  440.     LBRANCH( (CC&(CC_Z|CC_C)) );
  441. }
  442.  
  443. /* $24 BCC relative ----- */
  444. INLINE void bcc( void )
  445. {
  446.     BRANCH( !(CC&CC_C) );
  447. }
  448.  
  449. /* $1024 LBCC relative ----- */
  450. INLINE void lbcc( void )
  451. {
  452.     LBRANCH( !(CC&CC_C) );
  453. }
  454.  
  455. /* $25 BCS relative ----- */
  456. INLINE void bcs( void )
  457. {
  458.     BRANCH( (CC&CC_C) );
  459. }
  460.  
  461. /* $1025 LBCS relative ----- */
  462. INLINE void lbcs( void )
  463. {
  464.     LBRANCH( (CC&CC_C) );
  465. }
  466.  
  467. /* $26 BNE relative ----- */
  468. INLINE void bne( void )
  469. {
  470.     BRANCH( !(CC&CC_Z) );
  471. }
  472.  
  473. /* $1026 LBNE relative ----- */
  474. INLINE void lbne( void )
  475. {
  476.     LBRANCH( !(CC&CC_Z) );
  477. }
  478.  
  479. /* $27 BEQ relative ----- */
  480. INLINE void beq( void )
  481. {
  482.     BRANCH( (CC&CC_Z) );
  483. }
  484.  
  485. /* $1027 LBEQ relative ----- */
  486. INLINE void lbeq( void )
  487. {
  488.     LBRANCH( (CC&CC_Z) );
  489. }
  490.  
  491. /* $28 BVC relative ----- */
  492. INLINE void bvc( void )
  493. {
  494.     BRANCH( !(CC&CC_V) );
  495. }
  496.  
  497. /* $1028 LBVC relative ----- */
  498. INLINE void lbvc( void )
  499. {
  500.     LBRANCH( !(CC&CC_V) );
  501. }
  502.  
  503. /* $29 BVS relative ----- */
  504. INLINE void bvs( void )
  505. {
  506.     BRANCH( (CC&CC_V) );
  507. }
  508.  
  509. /* $1029 LBVS relative ----- */
  510. INLINE void lbvs( void )
  511. {
  512.     LBRANCH( (CC&CC_V) );
  513. }
  514.  
  515. /* $2A BPL relative ----- */
  516. INLINE void bpl( void )
  517. {
  518.     BRANCH( !(CC&CC_N) );
  519. }
  520.  
  521. /* $102A LBPL relative ----- */
  522. INLINE void lbpl( void )
  523. {
  524.     LBRANCH( !(CC&CC_N) );
  525. }
  526.  
  527. /* $2B BMI relative ----- */
  528. INLINE void bmi( void )
  529. {
  530.     BRANCH( (CC&CC_N) );
  531. }
  532.  
  533. /* $102B LBMI relative ----- */
  534. INLINE void lbmi( void )
  535. {
  536.     LBRANCH( (CC&CC_N) );
  537. }
  538.  
  539. /* $2C BGE relative ----- */
  540. INLINE void bge( void )
  541. {
  542.     BRANCH( !NXORV );
  543. }
  544.  
  545. /* $102C LBGE relative ----- */
  546. INLINE void lbge( void )
  547. {
  548.     LBRANCH( !NXORV );
  549. }
  550.  
  551. /* $2D BLT relative ----- */
  552. INLINE void blt( void )
  553. {
  554.     BRANCH( NXORV );
  555. }
  556.  
  557. /* $102D LBLT relative ----- */
  558. INLINE void lblt( void )
  559. {
  560.     LBRANCH( NXORV );
  561. }
  562.  
  563. /* $2E BGT relative ----- */
  564. INLINE void bgt( void )
  565. {
  566.     BRANCH( !(NXORV || (CC&CC_Z)) );
  567. }
  568.  
  569. /* $102E LBGT relative ----- */
  570. INLINE void lbgt( void )
  571. {
  572.     LBRANCH( !(NXORV || (CC&CC_Z)) );
  573. }
  574.  
  575. /* $2F BLE relative ----- */
  576. INLINE void ble( void )
  577. {
  578.     BRANCH( (NXORV || (CC&CC_Z)) );
  579. }
  580.  
  581. /* $102F LBLE relative ----- */
  582. INLINE void lble( void )
  583. {
  584.     LBRANCH( (NXORV || (CC&CC_Z)) );
  585. }
  586.  
  587. #if macintosh
  588. #pragma mark ____3x____
  589. #endif
  590.  
  591. /* $30 LEAX indexed --*-- */
  592. INLINE void leax( void )
  593. {
  594.     fetch_effective_address();
  595.     X = EA;
  596.     CLR_Z;
  597.     SET_Z(X);
  598. }
  599.  
  600. /* $31 LEAY indexed --*-- */
  601. INLINE void leay( void )
  602. {
  603.     fetch_effective_address();
  604.     Y = EA;
  605.     CLR_Z;
  606.     SET_Z(Y);
  607. }
  608.  
  609. /* $32 LEAS indexed ----- */
  610. INLINE void leas( void )
  611. {
  612.     fetch_effective_address();
  613.     S = EA;
  614.     m6809.int_state |= M6809_LDS;
  615. }
  616.  
  617. /* $33 LEAU indexed ----- */
  618. INLINE void leau( void )
  619. {
  620.     fetch_effective_address();
  621.     U = EA;
  622. }
  623.  
  624. /* $34 PSHS inherent ----- */
  625. INLINE void pshs( void )
  626. {
  627.     UINT8 t;
  628.     IMMBYTE(t);
  629.     if( t&0x80 ) { PUSHWORD(pPC); m6809_ICount -= 2; }
  630.     if( t&0x40 ) { PUSHWORD(pU);  m6809_ICount -= 2; }
  631.     if( t&0x20 ) { PUSHWORD(pY);  m6809_ICount -= 2; }
  632.     if( t&0x10 ) { PUSHWORD(pX);  m6809_ICount -= 2; }
  633.     if( t&0x08 ) { PUSHBYTE(DP);  m6809_ICount -= 1; }
  634.     if( t&0x04 ) { PUSHBYTE(B);   m6809_ICount -= 1; }
  635.     if( t&0x02 ) { PUSHBYTE(A);   m6809_ICount -= 1; }
  636.     if( t&0x01 ) { PUSHBYTE(CC);  m6809_ICount -= 1; }
  637. }
  638.  
  639. /* 35 PULS inherent ----- */
  640. INLINE void puls( void )
  641. {
  642.     UINT8 t;
  643.     IMMBYTE(t);
  644.     if( t&0x01 ) { PULLBYTE(CC); m6809_ICount -= 1; }
  645.     if( t&0x02 ) { PULLBYTE(A);  m6809_ICount -= 1; }
  646.     if( t&0x04 ) { PULLBYTE(B);  m6809_ICount -= 1; }
  647.     if( t&0x08 ) { PULLBYTE(DP); m6809_ICount -= 1; }
  648.     if( t&0x10 ) { PULLWORD(XD); m6809_ICount -= 2; }
  649.     if( t&0x20 ) { PULLWORD(YD); m6809_ICount -= 2; }
  650.     if( t&0x40 ) { PULLWORD(UD); m6809_ICount -= 2; }
  651.     if( t&0x80 ) { PULLWORD(PCD); CHANGE_PC; m6809_ICount -= 2; }
  652.  
  653.     /* HJB 990225: moved check after all PULLs */
  654.     if( t&0x01 ) { CHECK_IRQ_LINES; }
  655. }
  656.  
  657. /* $36 PSHU inherent ----- */
  658. INLINE void pshu( void )
  659. {
  660.     UINT8 t;
  661.     IMMBYTE(t);
  662.     if( t&0x80 ) { PSHUWORD(pPC); m6809_ICount -= 2; }
  663.     if( t&0x40 ) { PSHUWORD(pS);  m6809_ICount -= 2; }
  664.     if( t&0x20 ) { PSHUWORD(pY);  m6809_ICount -= 2; }
  665.     if( t&0x10 ) { PSHUWORD(pX);  m6809_ICount -= 2; }
  666.     if( t&0x08 ) { PSHUBYTE(DP);  m6809_ICount -= 1; }
  667.     if( t&0x04 ) { PSHUBYTE(B);   m6809_ICount -= 1; }
  668.     if( t&0x02 ) { PSHUBYTE(A);   m6809_ICount -= 1; }
  669.     if( t&0x01 ) { PSHUBYTE(CC);  m6809_ICount -= 1; }
  670. }
  671.  
  672. /* 37 PULU inherent ----- */
  673. INLINE void pulu( void )
  674. {
  675.     UINT8 t;
  676.     IMMBYTE(t);
  677.     if( t&0x01 ) { PULUBYTE(CC); m6809_ICount -= 1; }
  678.     if( t&0x02 ) { PULUBYTE(A);  m6809_ICount -= 1; }
  679.     if( t&0x04 ) { PULUBYTE(B);  m6809_ICount -= 1; }
  680.     if( t&0x08 ) { PULUBYTE(DP); m6809_ICount -= 1; }
  681.     if( t&0x10 ) { PULUWORD(XD); m6809_ICount -= 2; }
  682.     if( t&0x20 ) { PULUWORD(YD); m6809_ICount -= 2; }
  683.     if( t&0x40 ) { PULUWORD(SD); m6809_ICount -= 2; }
  684.     if( t&0x80 ) { PULUWORD(PCD); CHANGE_PC; m6809_ICount -= 2; }
  685.  
  686.     /* HJB 990225: moved check after all PULLs */
  687.     if( t&0x01 ) { CHECK_IRQ_LINES; }
  688. }
  689.  
  690. /* $38 ILLEGAL */
  691.  
  692. /* $39 RTS inherent ----- */
  693. INLINE void rts( void )
  694. {
  695.     PULLWORD(PCD);
  696.     CHANGE_PC;
  697. }
  698.  
  699. /* $3A ABX inherent ----- */
  700. INLINE void abx( void )
  701. {
  702.     X += B;
  703. }
  704.  
  705. /* $3B RTI inherent ##### */
  706. INLINE void rti( void )
  707. {
  708.     UINT8 t;
  709.     PULLBYTE(CC);
  710.     t = CC & CC_E;        /* HJB 990225: entire state saved? */
  711.     if(t)
  712.     {
  713.         m6809_ICount -= 9;
  714.         PULLBYTE(A);
  715.         PULLBYTE(B);
  716.         PULLBYTE(DP);
  717.         PULLWORD(XD);
  718.         PULLWORD(YD);
  719.         PULLWORD(UD);
  720.     }
  721.     PULLWORD(PCD);
  722.     CHANGE_PC;
  723.     CHECK_IRQ_LINES;    /* HJB 990116 */
  724. }
  725.  
  726. /* $3C CWAI inherent ----1 */
  727. INLINE void cwai( void )
  728. {
  729.     UINT8 t;
  730.     IMMBYTE(t);
  731.     CC &= t;
  732.     /*
  733.      * CWAI stacks the entire machine state on the hardware stack,
  734.      * then waits for an interrupt; when the interrupt is taken
  735.      * later, the state is *not* saved again after CWAI.
  736.      */
  737.     CC |= CC_E;         /* HJB 990225: save entire state */
  738.     PUSHWORD(pPC);
  739.     PUSHWORD(pU);
  740.     PUSHWORD(pY);
  741.     PUSHWORD(pX);
  742.     PUSHBYTE(DP);
  743.     PUSHBYTE(B);
  744.     PUSHBYTE(A);
  745.     PUSHBYTE(CC);
  746.     m6809.int_state |= M6809_CWAI;     /* HJB 990228 */
  747.     CHECK_IRQ_LINES;    /* HJB 990116 */
  748.     if( m6809.int_state & M6809_CWAI )
  749.         if( m6809_ICount > 0 )
  750.             m6809_ICount = 0;
  751. }
  752.  
  753. /* $3D MUL inherent --*-@ */
  754. INLINE void mul( void )
  755. {
  756.     UINT16 t;
  757.     t = A * B;
  758.     CLR_ZC; SET_Z16(t); if(t&0x80) SEC;
  759.     D = t;
  760. }
  761.  
  762. /* $3E ILLEGAL */
  763.  
  764. /* $3F SWI (SWI2 SWI3) absolute indirect ----- */
  765. INLINE void swi( void )
  766. {
  767.     CC |= CC_E;             /* HJB 980225: save entire state */
  768.     PUSHWORD(pPC);
  769.     PUSHWORD(pU);
  770.     PUSHWORD(pY);
  771.     PUSHWORD(pX);
  772.     PUSHBYTE(DP);
  773.     PUSHBYTE(B);
  774.     PUSHBYTE(A);
  775.     PUSHBYTE(CC);
  776.     CC |= CC_IF | CC_II;    /* inhibit FIRQ and IRQ */
  777.     PCD=RM16(0xfffa);
  778.     CHANGE_PC;
  779. }
  780.  
  781. /* $103F SWI2 absolute indirect ----- */
  782. INLINE void swi2( void )
  783. {
  784.     CC |= CC_E;             /* HJB 980225: save entire state */
  785.     PUSHWORD(pPC);
  786.     PUSHWORD(pU);
  787.     PUSHWORD(pY);
  788.     PUSHWORD(pX);
  789.     PUSHBYTE(DP);
  790.     PUSHBYTE(B);
  791.     PUSHBYTE(A);
  792.     PUSHBYTE(CC);
  793.     PCD = RM16(0xfff4);
  794.     CHANGE_PC;
  795. }
  796.  
  797. /* $113F SWI3 absolute indirect ----- */
  798. INLINE void swi3( void )
  799. {
  800.     CC |= CC_E;             /* HJB 980225: save entire state */
  801.     PUSHWORD(pPC);
  802.     PUSHWORD(pU);
  803.     PUSHWORD(pY);
  804.     PUSHWORD(pX);
  805.     PUSHBYTE(DP);
  806.     PUSHBYTE(B);
  807.     PUSHBYTE(A);
  808.     PUSHBYTE(CC);
  809.     PCD = RM16(0xfff2);
  810.     CHANGE_PC;
  811. }
  812.  
  813. #if macintosh
  814. #pragma mark ____4x____
  815. #endif
  816.  
  817. /* $40 NEGA inherent ?**** */
  818. INLINE void nega( void )
  819. {
  820.     UINT16 r;
  821.     r = -A;
  822.     CLR_NZVC;
  823.     SET_FLAGS8(0,A,r);
  824.     A = r;
  825. }
  826.  
  827. /* $41 ILLEGAL */
  828.  
  829. /* $42 ILLEGAL */
  830.  
  831. /* $43 COMA inherent -**01 */
  832. INLINE void coma( void )
  833. {
  834.     A = ~A;
  835.     CLR_NZV;
  836.     SET_NZ8(A);
  837.     SEC;
  838. }
  839.  
  840. /* $44 LSRA inherent -0*-* */
  841. INLINE void lsra( void )
  842. {
  843.     CLR_NZC;
  844.     CC |= (A & CC_C);
  845.     A >>= 1;
  846.     SET_Z8(A);
  847. }
  848.  
  849. /* $45 ILLEGAL */
  850.  
  851. /* $46 RORA inherent -**-* */
  852. INLINE void rora( void )
  853. {
  854.     UINT8 r;
  855.     r = (CC & CC_C) << 7;
  856.     CLR_NZC;
  857.     CC |= (A & CC_C);
  858.     r |= A >> 1;
  859.     SET_NZ8(r);
  860.     A = r;
  861. }
  862.  
  863. /* $47 ASRA inherent ?**-* */
  864. INLINE void asra( void )
  865. {
  866.     CLR_NZC;
  867.     CC |= (A & CC_C);
  868.     A = (A & 0x80) | (A >> 1);
  869.     SET_NZ8(A);
  870. }
  871.  
  872. /* $48 ASLA inherent ?**** */
  873. INLINE void asla( void )
  874. {
  875.     UINT16 r;
  876.     r = A << 1;
  877.     CLR_NZVC;
  878.     SET_FLAGS8(A,A,r);
  879.     A = r;
  880. }
  881.  
  882. /* $49 ROLA inherent -**** */
  883. INLINE void rola( void )
  884. {
  885.     UINT16 t,r;
  886.     t = A;
  887.     r = (CC & CC_C) | (t<<1);
  888.     CLR_NZVC; SET_FLAGS8(t,t,r);
  889.     A = r;
  890. }
  891.  
  892. /* $4A DECA inherent -***- */
  893. INLINE void deca( void )
  894. {
  895.     --A;
  896.     CLR_NZV;
  897.     SET_FLAGS8D(A);
  898. }
  899.  
  900. /* $4B ILLEGAL */
  901.  
  902. /* $4C INCA inherent -***- */
  903. INLINE void inca( void )
  904. {
  905.     ++A;
  906.     CLR_NZV;
  907.     SET_FLAGS8I(A);
  908. }
  909.  
  910. /* $4D TSTA inherent -**0- */
  911. INLINE void tsta( void )
  912. {
  913.     CLR_NZV;
  914.     SET_NZ8(A);
  915. }
  916.  
  917. /* $4E ILLEGAL */
  918.  
  919. /* $4F CLRA inherent -0100 */
  920. INLINE void clra( void )
  921. {
  922.     A = 0;
  923.     CLR_NZVC; SEZ;
  924. }
  925.  
  926. #if macintosh
  927. #pragma mark ____5x____
  928. #endif
  929.  
  930. /* $50 NEGB inherent ?**** */
  931. INLINE void negb( void )
  932. {
  933.     UINT16 r;
  934.     r = -B;
  935.     CLR_NZVC;
  936.     SET_FLAGS8(0,B,r);
  937.     B = r;
  938. }
  939.  
  940. /* $51 ILLEGAL */
  941.  
  942. /* $52 ILLEGAL */
  943.  
  944. /* $53 COMB inherent -**01 */
  945. INLINE void comb( void )
  946. {
  947.     B = ~B;
  948.     CLR_NZV;
  949.     SET_NZ8(B);
  950.     SEC;
  951. }
  952.  
  953. /* $54 LSRB inherent -0*-* */
  954. INLINE void lsrb( void )
  955. {
  956.     CLR_NZC;
  957.     CC |= (B & CC_C);
  958.     B >>= 1;
  959.     SET_Z8(B);
  960. }
  961.  
  962. /* $55 ILLEGAL */
  963.  
  964. /* $56 RORB inherent -**-* */
  965. INLINE void rorb( void )
  966. {
  967.     UINT8 r;
  968.     r = (CC & CC_C) << 7;
  969.     CLR_NZC;
  970.     CC |= (B & CC_C);
  971.     r |= B >> 1;
  972.     SET_NZ8(r);
  973.     B = r;
  974. }
  975.  
  976. /* $57 ASRB inherent ?**-* */
  977. INLINE void asrb( void )
  978. {
  979.     CLR_NZC;
  980.     CC |= (B & CC_C);
  981.     B= (B & 0x80) | (B >> 1);
  982.     SET_NZ8(B);
  983. }
  984.  
  985. /* $58 ASLB inherent ?**** */
  986. INLINE void aslb( void )
  987. {
  988.     UINT16 r;
  989.     r = B << 1;
  990.     CLR_NZVC;
  991.     SET_FLAGS8(B,B,r);
  992.     B = r;
  993. }
  994.  
  995. /* $59 ROLB inherent -**** */
  996. INLINE void rolb( void )
  997. {
  998.     UINT16 t,r;
  999.     t = B;
  1000.     r = CC & CC_C;
  1001.     r |= t << 1;
  1002.     CLR_NZVC;
  1003.     SET_FLAGS8(t,t,r);
  1004.     B = r;
  1005. }
  1006.  
  1007. /* $5A DECB inherent -***- */
  1008. INLINE void decb( void )
  1009. {
  1010.     --B;
  1011.     CLR_NZV;
  1012.     SET_FLAGS8D(B);
  1013. }
  1014.  
  1015. /* $5B ILLEGAL */
  1016.  
  1017. /* $5C INCB inherent -***- */
  1018. INLINE void incb( void )
  1019. {
  1020.     ++B;
  1021.     CLR_NZV;
  1022.     SET_FLAGS8I(B);
  1023. }
  1024.  
  1025. /* $5D TSTB inherent -**0- */
  1026. INLINE void tstb( void )
  1027. {
  1028.     CLR_NZV;
  1029.     SET_NZ8(B);
  1030. }
  1031.  
  1032. /* $5E ILLEGAL */
  1033.  
  1034. /* $5F CLRB inherent -0100 */
  1035. INLINE void clrb( void )
  1036. {
  1037.     B = 0;
  1038.     CLR_NZVC; SEZ;
  1039. }
  1040.  
  1041. #if macintosh
  1042. #pragma mark ____6x____
  1043. #endif
  1044.  
  1045. /* $60 NEG indexed ?**** */
  1046. INLINE void neg_ix( void )
  1047. {
  1048.     UINT16 r,t;
  1049.     fetch_effective_address();
  1050.     t = RM(EAD);
  1051.     r=-t;
  1052.     CLR_NZVC;
  1053.     SET_FLAGS8(0,t,r);
  1054.     WM(EAD,r);
  1055. }
  1056.  
  1057. /* $61 ILLEGAL */
  1058.  
  1059. /* $62 ILLEGAL */
  1060.  
  1061. /* $63 COM indexed -**01 */
  1062. INLINE void com_ix( void )
  1063. {
  1064.     UINT8 t;
  1065.     fetch_effective_address();
  1066.     t = ~RM(EAD);
  1067.     CLR_NZV;
  1068.     SET_NZ8(t);
  1069.     SEC;
  1070.     WM(EAD,t);
  1071. }
  1072.  
  1073. /* $64 LSR indexed -0*-* */
  1074. INLINE void lsr_ix( void )
  1075. {
  1076.     UINT8 t;
  1077.     fetch_effective_address();
  1078.     t=RM(EAD);
  1079.     CLR_NZC;
  1080.     CC |= (t & CC_C);
  1081.     t>>=1; SET_Z8(t);
  1082.     WM(EAD,t);
  1083. }
  1084.  
  1085. /* $65 ILLEGAL */
  1086.  
  1087. /* $66 ROR indexed -**-* */
  1088. INLINE void ror_ix( void )
  1089. {
  1090.     UINT8 t,r;
  1091.     fetch_effective_address();
  1092.     t=RM(EAD);
  1093.     r = (CC & CC_C) << 7;
  1094.     CLR_NZC;
  1095.     CC |= (t & CC_C);
  1096.     r |= t>>1; SET_NZ8(r);
  1097.     WM(EAD,r);
  1098. }
  1099.  
  1100. /* $67 ASR indexed ?**-* */
  1101. INLINE void asr_ix( void )
  1102. {
  1103.     UINT8 t;
  1104.     fetch_effective_address();
  1105.     t=RM(EAD);
  1106.     CLR_NZC;
  1107.     CC |= (t & CC_C);
  1108.     t=(t&0x80)|(t>>1);
  1109.     SET_NZ8(t);
  1110.     WM(EAD,t);
  1111. }
  1112.  
  1113. /* $68 ASL indexed ?**** */
  1114. INLINE void asl_ix( void )
  1115. {
  1116.     UINT16 t,r;
  1117.     fetch_effective_address();
  1118.     t=RM(EAD);
  1119.     r = t << 1;
  1120.     CLR_NZVC;
  1121.     SET_FLAGS8(t,t,r);
  1122.     WM(EAD,r);
  1123. }
  1124.  
  1125. /* $69 ROL indexed -**** */
  1126. INLINE void rol_ix( void )
  1127. {
  1128.     UINT16 t,r;
  1129.     fetch_effective_address();
  1130.     t=RM(EAD);
  1131.     r = CC & CC_C;
  1132.     r |= t << 1;
  1133.     CLR_NZVC;
  1134.     SET_FLAGS8(t,t,r);
  1135.     WM(EAD,r);
  1136. }
  1137.  
  1138. /* $6A DEC indexed -***- */
  1139. INLINE void dec_ix( void )
  1140. {
  1141.     UINT8 t;
  1142.     fetch_effective_address();
  1143.     t = RM(EAD) - 1;
  1144.     CLR_NZV; SET_FLAGS8D(t);
  1145.     WM(EAD,t);
  1146. }
  1147.  
  1148. /* $6B ILLEGAL */
  1149.  
  1150. /* $6C INC indexed -***- */
  1151. INLINE void inc_ix( void )
  1152. {
  1153.     UINT8 t;
  1154.     fetch_effective_address();
  1155.     t = RM(EAD) + 1;
  1156.     CLR_NZV; SET_FLAGS8I(t);
  1157.     WM(EAD,t);
  1158. }
  1159.  
  1160. /* $6D TST indexed -**0- */
  1161. INLINE void tst_ix( void )
  1162. {
  1163.     UINT8 t;
  1164.     fetch_effective_address();
  1165.     t = RM(EAD);
  1166.     CLR_NZV;
  1167.     SET_NZ8(t);
  1168. }
  1169.  
  1170. /* $6E JMP indexed ----- */
  1171. INLINE void jmp_ix( void )
  1172. {
  1173.     fetch_effective_address();
  1174.     PCD = EAD;
  1175.     CHANGE_PC;
  1176. }
  1177.  
  1178. /* $6F CLR indexed -0100 */
  1179. INLINE void clr_ix( void )
  1180. {
  1181.     fetch_effective_address();
  1182.     WM(EAD,0);
  1183.     CLR_NZVC; SEZ;
  1184. }
  1185.  
  1186. #if macintosh
  1187. #pragma mark ____7x____
  1188. #endif
  1189.  
  1190. /* $70 NEG extended ?**** */
  1191. INLINE void neg_ex( void )
  1192. {
  1193.     UINT16 r,t;
  1194.     EXTBYTE(t); r=-t;
  1195.     CLR_NZVC; SET_FLAGS8(0,t,r);
  1196.     WM(EAD,r);
  1197. }
  1198.  
  1199. /* $71 ILLEGAL */
  1200.  
  1201. /* $72 ILLEGAL */
  1202.  
  1203. /* $73 COM extended -**01 */
  1204. INLINE void com_ex( void )
  1205. {
  1206.     UINT8 t;
  1207.     EXTBYTE(t); t = ~t;
  1208.     CLR_NZV; SET_NZ8(t); SEC;
  1209.     WM(EAD,t);
  1210. }
  1211.  
  1212. /* $74 LSR extended -0*-* */
  1213. INLINE void lsr_ex( void )
  1214. {
  1215.     UINT8 t;
  1216.     EXTBYTE(t); CLR_NZC; CC |= (t & CC_C);
  1217.     t>>=1; SET_Z8(t);
  1218.     WM(EAD,t);
  1219. }
  1220.  
  1221. /* $75 ILLEGAL */
  1222.  
  1223. /* $76 ROR extended -**-* */
  1224. INLINE void ror_ex( void )
  1225. {
  1226.     UINT8 t,r;
  1227.     EXTBYTE(t); r=(CC & CC_C) << 7;
  1228.     CLR_NZC; CC |= (t & CC_C);
  1229.     r |= t>>1; SET_NZ8(r);
  1230.     WM(EAD,r);
  1231. }
  1232.  
  1233. /* $77 ASR extended ?**-* */
  1234. INLINE void asr_ex( void )
  1235. {
  1236.     UINT8 t;
  1237.     EXTBYTE(t); CLR_NZC; CC |= (t & CC_C);
  1238.     t=(t&0x80)|(t>>1);
  1239.     SET_NZ8(t);
  1240.     WM(EAD,t);
  1241. }
  1242.  
  1243. /* $78 ASL extended ?**** */
  1244. INLINE void asl_ex( void )
  1245. {
  1246.     UINT16 t,r;
  1247.     EXTBYTE(t); r=t<<1;
  1248.     CLR_NZVC; SET_FLAGS8(t,t,r);
  1249.     WM(EAD,r);
  1250. }
  1251.  
  1252. /* $79 ROL extended -**** */
  1253. INLINE void rol_ex( void )
  1254. {
  1255.     UINT16 t,r;
  1256.     EXTBYTE(t); r = (CC & CC_C) | (t << 1);
  1257.     CLR_NZVC; SET_FLAGS8(t,t,r);
  1258.     WM(EAD,r);
  1259. }
  1260.  
  1261. /* $7A DEC extended -***- */
  1262. INLINE void dec_ex( void )
  1263. {
  1264.     UINT8 t;
  1265.     EXTBYTE(t); --t;
  1266.     CLR_NZV; SET_FLAGS8D(t);
  1267.     WM(EAD,t);
  1268. }
  1269.  
  1270. /* $7B ILLEGAL */
  1271.  
  1272. /* $7C INC extended -***- */
  1273. INLINE void inc_ex( void )
  1274. {
  1275.     UINT8 t;
  1276.     EXTBYTE(t); ++t;
  1277.     CLR_NZV; SET_FLAGS8I(t);
  1278.     WM(EAD,t);
  1279. }
  1280.  
  1281. /* $7D TST extended -**0- */
  1282. INLINE void tst_ex( void )
  1283. {
  1284.     UINT8 t;
  1285.     EXTBYTE(t); CLR_NZV; SET_NZ8(t);
  1286. }
  1287.  
  1288. /* $7E JMP extended ----- */
  1289. INLINE void jmp_ex( void )
  1290. {
  1291.     EXTENDED;
  1292.     PCD = EAD;
  1293.     CHANGE_PC;
  1294. }
  1295.  
  1296. /* $7F CLR extended -0100 */
  1297. INLINE void clr_ex( void )
  1298. {
  1299.     EXTENDED;
  1300.     WM(EAD,0);
  1301.     CLR_NZVC; SEZ;
  1302. }
  1303.  
  1304.  
  1305. #if macintosh
  1306. #pragma mark ____8x____
  1307. #endif
  1308.  
  1309. /* $80 SUBA immediate ?**** */
  1310. INLINE void suba_im( void )
  1311. {
  1312.     UINT16 t,r;
  1313.     IMMBYTE(t);
  1314.     r = A - t;
  1315.     CLR_NZVC;
  1316.     SET_FLAGS8(A,t,r);
  1317.     A = r;
  1318. }
  1319.  
  1320. /* $81 CMPA immediate ?**** */
  1321. INLINE void cmpa_im( void )
  1322. {
  1323.     UINT16      t,r;
  1324.     IMMBYTE(t);
  1325.     r = A - t;
  1326.     CLR_NZVC;
  1327.     SET_FLAGS8(A,t,r);
  1328. }
  1329.  
  1330. /* $82 SBCA immediate ?**** */
  1331. INLINE void sbca_im( void )
  1332. {
  1333.     UINT16      t,r;
  1334.     IMMBYTE(t);
  1335.     r = A - t - (CC & CC_C);
  1336.     CLR_NZVC;
  1337.     SET_FLAGS8(A,t,r);
  1338.     A = r;
  1339. }
  1340.  
  1341. /* $83 SUBD (CMPD CMPU) immediate -**** */
  1342. INLINE void subd_im( void )
  1343. {
  1344.     UINT32 r,d;
  1345.     PAIR b;
  1346.     IMMWORD(b);
  1347.     d = D;
  1348.     r = d - b.d;
  1349.     CLR_NZVC;
  1350.     SET_FLAGS16(d,b.d,r);
  1351.     D = r;
  1352. }
  1353.  
  1354. /* $1083 CMPD immediate -**** */
  1355. INLINE void cmpd_im( void )
  1356. {
  1357.     UINT32 r,d;
  1358.     PAIR b;
  1359.     IMMWORD(b);
  1360.     d = D;
  1361.     r = d - b.d;
  1362.     CLR_NZVC;
  1363.     SET_FLAGS16(d,b.d,r);
  1364. }
  1365.  
  1366. /* $1183 CMPU immediate -**** */
  1367. INLINE void cmpu_im( void )
  1368. {
  1369.     UINT32 r, d;
  1370.     PAIR b;
  1371.     IMMWORD(b);
  1372.     d = U;
  1373.     r = d - b.d;
  1374.     CLR_NZVC;
  1375.     SET_FLAGS16(d,b.d,r);
  1376. }
  1377.  
  1378. /* $84 ANDA immediate -**0- */
  1379. INLINE void anda_im( void )
  1380. {
  1381.     UINT8 t;
  1382.     IMMBYTE(t);
  1383.     A &= t;
  1384.     CLR_NZV;
  1385.     SET_NZ8(A);
  1386. }
  1387.  
  1388. /* $85 BITA immediate -**0- */
  1389. INLINE void bita_im( void )
  1390. {
  1391.     UINT8 t,r;
  1392.     IMMBYTE(t);
  1393.     r = A & t;
  1394.     CLR_NZV;
  1395.     SET_NZ8(r);
  1396. }
  1397.  
  1398. /* $86 LDA immediate -**0- */
  1399. INLINE void lda_im( void )
  1400. {
  1401.     IMMBYTE(A);
  1402.     CLR_NZV;
  1403.     SET_NZ8(A);
  1404. }
  1405.  
  1406. /* is this a legal instruction? */
  1407. /* $87 STA immediate -**0- */
  1408. INLINE void sta_im( void )
  1409. {
  1410.     CLR_NZV;
  1411.     SET_NZ8(A);
  1412.     IMM8;
  1413.     WM(EAD,A);
  1414. }
  1415.  
  1416. /* $88 EORA immediate -**0- */
  1417. INLINE void eora_im( void )
  1418. {
  1419.     UINT8 t;
  1420.     IMMBYTE(t);
  1421.     A ^= t;
  1422.     CLR_NZV;
  1423.     SET_NZ8(A);
  1424. }
  1425.  
  1426. /* $89 ADCA immediate ***** */
  1427. INLINE void adca_im( void )
  1428. {
  1429.     UINT16 t,r;
  1430.     IMMBYTE(t);
  1431.     r = A + t + (CC & CC_C);
  1432.     CLR_HNZVC;
  1433.     SET_FLAGS8(A,t,r);
  1434.     SET_H(A,t,r);
  1435.     A = r;
  1436. }
  1437.  
  1438. /* $8A ORA immediate -**0- */
  1439. INLINE void ora_im( void )
  1440. {
  1441.     UINT8 t;
  1442.     IMMBYTE(t);
  1443.     A |= t;
  1444.     CLR_NZV;
  1445.     SET_NZ8(A);
  1446. }
  1447.  
  1448. /* $8B ADDA immediate ***** */
  1449. INLINE void adda_im( void )
  1450. {
  1451.     UINT16 t,r;
  1452.     IMMBYTE(t);
  1453.     r = A + t;
  1454.     CLR_HNZVC;
  1455.     SET_FLAGS8(A,t,r);
  1456.     SET_H(A,t,r);
  1457.     A = r;
  1458. }
  1459.  
  1460. /* $8C CMPX (CMPY CMPS) immediate -**** */
  1461. INLINE void cmpx_im( void )
  1462. {
  1463.     UINT32 r,d;
  1464.     PAIR b;
  1465.     IMMWORD(b);
  1466.     d = X;
  1467.     r = d - b.d;
  1468.     CLR_NZVC;
  1469.     SET_FLAGS16(d,b.d,r);
  1470. }
  1471.  
  1472. /* $108C CMPY immediate -**** */
  1473. INLINE void cmpy_im( void )
  1474. {
  1475.     UINT32 r,d;
  1476.     PAIR b;
  1477.     IMMWORD(b);
  1478.     d = Y;
  1479.     r = d - b.d;
  1480.     CLR_NZVC;
  1481.     SET_FLAGS16(d,b.d,r);
  1482. }
  1483.  
  1484. /* $118C CMPS immediate -**** */
  1485. INLINE void cmps_im( void )
  1486. {
  1487.     UINT32 r,d;
  1488.     PAIR b;
  1489.     IMMWORD(b);
  1490.     d = S;
  1491.     r = d - b.d;
  1492.     CLR_NZVC;
  1493.     SET_FLAGS16(d,b.d,r);
  1494. }
  1495.  
  1496. /* $8D BSR ----- */
  1497. INLINE void bsr( void )
  1498. {
  1499.     UINT8 t;
  1500.     IMMBYTE(t);
  1501.     PUSHWORD(pPC);
  1502.     PC += SIGNED(t);
  1503.     CHANGE_PC;
  1504. }
  1505.  
  1506. /* $8E LDX (LDY) immediate -**0- */
  1507. INLINE void ldx_im( void )
  1508. {
  1509.     IMMWORD(pX);
  1510.     CLR_NZV;
  1511.     SET_NZ16(X);
  1512. }
  1513.  
  1514. /* $108E LDY immediate -**0- */
  1515. INLINE void ldy_im( void )
  1516. {
  1517.     IMMWORD(pY);
  1518.     CLR_NZV;
  1519.     SET_NZ16(Y);
  1520. }
  1521.  
  1522. /* is this a legal instruction? */
  1523. /* $8F STX (STY) immediate -**0- */
  1524. INLINE void stx_im( void )
  1525. {
  1526.     CLR_NZV;
  1527.     SET_NZ16(X);
  1528.     IMM16;
  1529.     WM16(EAD,&pX);
  1530. }
  1531.  
  1532. /* is this a legal instruction? */
  1533. /* $108F STY immediate -**0- */
  1534. INLINE void sty_im( void )
  1535. {
  1536.     CLR_NZV;
  1537.     SET_NZ16(Y);
  1538.     IMM16;
  1539.     WM16(EAD,&pY);
  1540. }
  1541.  
  1542. #if macintosh
  1543. #pragma mark ____9x____
  1544. #endif
  1545.  
  1546. /* $90 SUBA direct ?**** */
  1547. INLINE void suba_di( void )
  1548. {
  1549.     UINT16      t,r;
  1550.     DIRBYTE(t);
  1551.     r = A - t;
  1552.     CLR_NZVC;
  1553.     SET_FLAGS8(A,t,r);
  1554.     A = r;
  1555. }
  1556.  
  1557. /* $91 CMPA direct ?**** */
  1558. INLINE void cmpa_di( void )
  1559. {
  1560.     UINT16      t,r;
  1561.     DIRBYTE(t);
  1562.     r = A - t;
  1563.     CLR_NZVC;
  1564.     SET_FLAGS8(A,t,r);
  1565. }
  1566.  
  1567. /* $92 SBCA direct ?**** */
  1568. INLINE void sbca_di( void )
  1569. {
  1570.     UINT16      t,r;
  1571.     DIRBYTE(t);
  1572.     r = A - t - (CC & CC_C);
  1573.     CLR_NZVC;
  1574.     SET_FLAGS8(A,t,r);
  1575.     A = r;
  1576. }
  1577.  
  1578. /* $93 SUBD (CMPD CMPU) direct -**** */
  1579. INLINE void subd_di( void )
  1580. {
  1581.     UINT32 r,d;
  1582.     PAIR b;
  1583.     DIRWORD(b);
  1584.     d = D;
  1585.     r = d - b.d;
  1586.     CLR_NZVC;
  1587.     SET_FLAGS16(d,b.d,r);
  1588.     D = r;
  1589. }
  1590.  
  1591. /* $1093 CMPD direct -**** */
  1592. INLINE void cmpd_di( void )
  1593. {
  1594.     UINT32 r,d;
  1595.     PAIR b;
  1596.     DIRWORD(b);
  1597.     d = D;
  1598.     r = d - b.d;
  1599.     CLR_NZVC;
  1600.     SET_FLAGS16(d,b.d,r);
  1601. }
  1602.  
  1603. /* $1193 CMPU direct -**** */
  1604. INLINE void cmpu_di( void )
  1605. {
  1606.     UINT32 r,d;
  1607.     PAIR b;
  1608.     DIRWORD(b);
  1609.     d = U;
  1610.     r = d - b.d;
  1611.     CLR_NZVC;
  1612.     SET_FLAGS16(U,b.d,r);
  1613. }
  1614.  
  1615. /* $94 ANDA direct -**0- */
  1616. INLINE void anda_di( void )
  1617. {
  1618.     UINT8 t;
  1619.     DIRBYTE(t);
  1620.     A &= t;
  1621.     CLR_NZV;
  1622.     SET_NZ8(A);
  1623. }
  1624.  
  1625. /* $95 BITA direct -**0- */
  1626. INLINE void bita_di( void )
  1627. {
  1628.     UINT8 t,r;
  1629.     DIRBYTE(t);
  1630.     r = A & t;
  1631.     CLR_NZV;
  1632.     SET_NZ8(r);
  1633. }
  1634.  
  1635. /* $96 LDA direct -**0- */
  1636. INLINE void lda_di( void )
  1637. {
  1638.     DIRBYTE(A);
  1639.     CLR_NZV;
  1640.     SET_NZ8(A);
  1641. }
  1642.  
  1643. /* $97 STA direct -**0- */
  1644. INLINE void sta_di( void )
  1645. {
  1646.     CLR_NZV;
  1647.     SET_NZ8(A);
  1648.     DIRECT;
  1649.     WM(EAD,A);
  1650. }
  1651.  
  1652. /* $98 EORA direct -**0- */
  1653. INLINE void eora_di( void )
  1654. {
  1655.     UINT8 t;
  1656.     DIRBYTE(t);
  1657.     A ^= t;
  1658.     CLR_NZV;
  1659.     SET_NZ8(A);
  1660. }
  1661.  
  1662. /* $99 ADCA direct ***** */
  1663. INLINE void adca_di( void )
  1664. {
  1665.     UINT16 t,r;
  1666.     DIRBYTE(t);
  1667.     r = A + t + (CC & CC_C);
  1668.     CLR_HNZVC;
  1669.     SET_FLAGS8(A,t,r);
  1670.     SET_H(A,t,r);
  1671.     A = r;
  1672. }
  1673.  
  1674. /* $9A ORA direct -**0- */
  1675. INLINE void ora_di( void )
  1676. {
  1677.     UINT8 t;
  1678.     DIRBYTE(t);
  1679.     A |= t;
  1680.     CLR_NZV;
  1681.     SET_NZ8(A);
  1682. }
  1683.  
  1684. /* $9B ADDA direct ***** */
  1685. INLINE void adda_di( void )
  1686. {
  1687.     UINT16 t,r;
  1688.     DIRBYTE(t);
  1689.     r = A + t;
  1690.     CLR_HNZVC;
  1691.     SET_FLAGS8(A,t,r);
  1692.     SET_H(A,t,r);
  1693.     A = r;
  1694. }
  1695.  
  1696. /* $9C CMPX (CMPY CMPS) direct -**** */
  1697. INLINE void cmpx_di( void )
  1698. {
  1699.     UINT32 r,d;
  1700.     PAIR b;
  1701.     DIRWORD(b);
  1702.     d = X;
  1703.     r = d - b.d;
  1704.     CLR_NZVC;
  1705.     SET_FLAGS16(d,b.d,r);
  1706. }
  1707.  
  1708. /* $109C CMPY direct -**** */
  1709. INLINE void cmpy_di( void )
  1710. {
  1711.     UINT32 r,d;
  1712.     PAIR b;
  1713.     DIRWORD(b);
  1714.     d = Y;
  1715.     r = d - b.d;
  1716.     CLR_NZVC;
  1717.     SET_FLAGS16(d,b.d,r);
  1718. }
  1719.  
  1720. /* $119C CMPS direct -**** */
  1721. INLINE void cmps_di( void )
  1722. {
  1723.     UINT32 r,d;
  1724.     PAIR b;
  1725.     DIRWORD(b);
  1726.     d = S;
  1727.     r = d - b.d;
  1728.     CLR_NZVC;
  1729.     SET_FLAGS16(d,b.d,r);
  1730. }
  1731.  
  1732. /* $9D JSR direct ----- */
  1733. INLINE void jsr_di( void )
  1734. {
  1735.     DIRECT;
  1736.     PUSHWORD(pPC);
  1737.     PCD = EAD;
  1738.     CHANGE_PC;
  1739. }
  1740.  
  1741. /* $9E LDX (LDY) direct -**0- */
  1742. INLINE void ldx_di( void )
  1743. {
  1744.     DIRWORD(pX);
  1745.     CLR_NZV;
  1746.     SET_NZ16(X);
  1747. }
  1748.  
  1749. /* $109E LDY direct -**0- */
  1750. INLINE void ldy_di( void )
  1751. {
  1752.     DIRWORD(pY);
  1753.     CLR_NZV;
  1754.     SET_NZ16(Y);
  1755. }
  1756.  
  1757. /* $9F STX (STY) direct -**0- */
  1758. INLINE void stx_di( void )
  1759. {
  1760.     CLR_NZV;
  1761.     SET_NZ16(X);
  1762.     DIRECT;
  1763.     WM16(EAD,&pX);
  1764. }
  1765.  
  1766. /* $109F STY direct -**0- */
  1767. INLINE void sty_di( void )
  1768. {
  1769.     CLR_NZV;
  1770.     SET_NZ16(Y);
  1771.     DIRECT;
  1772.     WM16(EAD,&pY);
  1773. }
  1774.  
  1775. #if macintosh
  1776. #pragma mark ____Ax____
  1777. #endif
  1778.  
  1779.  
  1780. /* $a0 SUBA indexed ?**** */
  1781. INLINE void suba_ix( void )
  1782. {
  1783.     UINT16 t,r;
  1784.     fetch_effective_address();
  1785.     t = RM(EAD);
  1786.     r = A - t;
  1787.     CLR_NZVC;
  1788.     SET_FLAGS8(A,t,r);
  1789.     A = r;
  1790. }
  1791.  
  1792. /* $a1 CMPA indexed ?**** */
  1793. INLINE void cmpa_ix( void )
  1794. {
  1795.     UINT16 t,r;
  1796.     fetch_effective_address();
  1797.     t = RM(EAD);
  1798.     r = A - t;
  1799.     CLR_NZVC;
  1800.     SET_FLAGS8(A,t,r);
  1801. }
  1802.  
  1803. /* $a2 SBCA indexed ?**** */
  1804. INLINE void sbca_ix( void )
  1805. {
  1806.     UINT16      t,r;
  1807.     fetch_effective_address();
  1808.     t = RM(EAD);
  1809.     r = A - t - (CC & CC_C);
  1810.     CLR_NZVC;
  1811.     SET_FLAGS8(A,t,r);
  1812.     A = r;
  1813. }
  1814.  
  1815. /* $a3 SUBD (CMPD CMPU) indexed -**** */
  1816. INLINE void subd_ix( void )
  1817. {
  1818.     UINT32 r,d;
  1819.     PAIR b;
  1820.     fetch_effective_address();
  1821.     b.d=RM16(EAD);
  1822.     d = D;
  1823.     r = d - b.d;
  1824.     CLR_NZVC;
  1825.     SET_FLAGS16(d,b.d,r);
  1826.     D = r;
  1827. }
  1828.  
  1829. /* $10a3 CMPD indexed -**** */
  1830. INLINE void cmpd_ix( void )
  1831. {
  1832.     UINT32 r,d;
  1833.     PAIR b;
  1834.     fetch_effective_address();
  1835.     b.d=RM16(EAD);
  1836.     d = D;
  1837.     r = d - b.d;
  1838.     CLR_NZVC;
  1839.     SET_FLAGS16(d,b.d,r);
  1840. }
  1841.  
  1842. /* $11a3 CMPU indexed -**** */
  1843. INLINE void cmpu_ix( void )
  1844. {
  1845.     UINT32 r;
  1846.     PAIR b;
  1847.     fetch_effective_address();
  1848.     b.d=RM16(EAD);
  1849.     r = U - b.d;
  1850.     CLR_NZVC;
  1851.     SET_FLAGS16(U,b.d,r);
  1852. }
  1853.  
  1854. /* $a4 ANDA indexed -**0- */
  1855. INLINE void anda_ix( void )
  1856. {
  1857.     fetch_effective_address();
  1858.     A &= RM(EAD);
  1859.     CLR_NZV;
  1860.     SET_NZ8(A);
  1861. }
  1862.  
  1863. /* $a5 BITA indexed -**0- */
  1864. INLINE void bita_ix( void )
  1865. {
  1866.     UINT8 r;
  1867.     fetch_effective_address();
  1868.     r = A & RM(EAD);
  1869.     CLR_NZV;
  1870.     SET_NZ8(r);
  1871. }
  1872.  
  1873. /* $a6 LDA indexed -**0- */
  1874. INLINE void lda_ix( void )
  1875. {
  1876.     fetch_effective_address();
  1877.     A = RM(EAD);
  1878.     CLR_NZV;
  1879.     SET_NZ8(A);
  1880. }
  1881.  
  1882. /* $a7 STA indexed -**0- */
  1883. INLINE void sta_ix( void )
  1884. {
  1885.     fetch_effective_address();
  1886.     CLR_NZV;
  1887.     SET_NZ8(A);
  1888.     WM(EAD,A);
  1889. }
  1890.  
  1891. /* $a8 EORA indexed -**0- */
  1892. INLINE void eora_ix( void )
  1893. {
  1894.     fetch_effective_address();
  1895.     A ^= RM(EAD);
  1896.     CLR_NZV;
  1897.     SET_NZ8(A);
  1898. }
  1899.  
  1900. /* $a9 ADCA indexed ***** */
  1901. INLINE void adca_ix( void )
  1902. {
  1903.     UINT16 t,r;
  1904.     fetch_effective_address();
  1905.     t = RM(EAD);
  1906.     r = A + t + (CC & CC_C);
  1907.     CLR_HNZVC;
  1908.     SET_FLAGS8(A,t,r);
  1909.     SET_H(A,t,r);
  1910.     A = r;
  1911. }
  1912.  
  1913. /* $aA ORA indexed -**0- */
  1914. INLINE void ora_ix( void )
  1915. {
  1916.     fetch_effective_address();
  1917.     A |= RM(EAD);
  1918.     CLR_NZV;
  1919.     SET_NZ8(A);
  1920. }
  1921.  
  1922. /* $aB ADDA indexed ***** */
  1923. INLINE void adda_ix( void )
  1924. {
  1925.     UINT16 t,r;
  1926.     fetch_effective_address();
  1927.     t = RM(EAD);
  1928.     r = A + t;
  1929.     CLR_HNZVC;
  1930.     SET_FLAGS8(A,t,r);
  1931.     SET_H(A,t,r);
  1932.     A = r;
  1933. }
  1934.  
  1935. /* $aC CMPX (CMPY CMPS) indexed -**** */
  1936. INLINE void cmpx_ix( void )
  1937. {
  1938.     UINT32 r,d;
  1939.     PAIR b;
  1940.     fetch_effective_address();
  1941.     b.d=RM16(EAD);
  1942.     d = X;
  1943.     r = d - b.d;
  1944.     CLR_NZVC;
  1945.     SET_FLAGS16(d,b.d,r);
  1946. }
  1947.  
  1948. /* $10aC CMPY indexed -**** */
  1949. INLINE void cmpy_ix( void )
  1950. {
  1951.     UINT32 r,d;
  1952.     PAIR b;
  1953.     fetch_effective_address();
  1954.     b.d=RM16(EAD);
  1955.     d = Y;
  1956.     r = d - b.d;
  1957.     CLR_NZVC;
  1958.     SET_FLAGS16(d,b.d,r);
  1959. }
  1960.  
  1961. /* $11aC CMPS indexed -**** */
  1962. INLINE void cmps_ix( void )
  1963. {
  1964.     UINT32 r,d;
  1965.     PAIR b;
  1966.     fetch_effective_address();
  1967.     b.d=RM16(EAD);
  1968.     d = S;
  1969.     r = d - b.d;
  1970.     CLR_NZVC;
  1971.     SET_FLAGS16(d,b.d,r);
  1972. }
  1973.  
  1974. /* $aD JSR indexed ----- */
  1975. INLINE void jsr_ix( void )
  1976. {
  1977.     fetch_effective_address();
  1978.     PUSHWORD(pPC);
  1979.     PCD = EAD;
  1980.     CHANGE_PC;
  1981. }
  1982.  
  1983. /* $aE LDX (LDY) indexed -**0- */
  1984. INLINE void ldx_ix( void )
  1985. {
  1986.     fetch_effective_address();
  1987.     X=RM16(EAD);
  1988.     CLR_NZV;
  1989.     SET_NZ16(X);
  1990. }
  1991.  
  1992. /* $10aE LDY indexed -**0- */
  1993. INLINE void ldy_ix( void )
  1994. {
  1995.     fetch_effective_address();
  1996.     Y=RM16(EAD);
  1997.     CLR_NZV;
  1998.     SET_NZ16(Y);
  1999. }
  2000.  
  2001. /* $aF STX (STY) indexed -**0- */
  2002. INLINE void stx_ix( void )
  2003. {
  2004.     fetch_effective_address();
  2005.     CLR_NZV;
  2006.     SET_NZ16(X);
  2007.     WM16(EAD,&pX);
  2008. }
  2009.  
  2010. /* $10aF STY indexed -**0- */
  2011. INLINE void sty_ix( void )
  2012. {
  2013.     fetch_effective_address();
  2014.     CLR_NZV;
  2015.     SET_NZ16(Y);
  2016.     WM16(EAD,&pY);
  2017. }
  2018.  
  2019. #if macintosh
  2020. #pragma mark ____Bx____
  2021. #endif
  2022.  
  2023. /* $b0 SUBA extended ?**** */
  2024. INLINE void suba_ex( void )
  2025. {
  2026.     UINT16      t,r;
  2027.     EXTBYTE(t);
  2028.     r = A - t;
  2029.     CLR_NZVC;
  2030.     SET_FLAGS8(A,t,r);
  2031.     A = r;
  2032. }
  2033.  
  2034. /* $b1 CMPA extended ?**** */
  2035. INLINE void cmpa_ex( void )
  2036. {
  2037.     UINT16      t,r;
  2038.     EXTBYTE(t);
  2039.     r = A - t;
  2040.     CLR_NZVC;
  2041.     SET_FLAGS8(A,t,r);
  2042. }
  2043.  
  2044. /* $b2 SBCA extended ?**** */
  2045. INLINE void sbca_ex( void )
  2046. {
  2047.     UINT16      t,r;
  2048.     EXTBYTE(t);
  2049.     r = A - t - (CC & CC_C);
  2050.     CLR_NZVC;
  2051.     SET_FLAGS8(A,t,r);
  2052.     A = r;
  2053. }
  2054.  
  2055. /* $b3 SUBD (CMPD CMPU) extended -**** */
  2056. INLINE void subd_ex( void )
  2057. {
  2058.     UINT32 r,d;
  2059.     PAIR b;
  2060.     EXTWORD(b);
  2061.     d = D;
  2062.     r = d - b.d;
  2063.     CLR_NZVC;
  2064.     SET_FLAGS16(d,b.d,r);
  2065.     D = r;
  2066. }
  2067.  
  2068. /* $10b3 CMPD extended -**** */
  2069. INLINE void cmpd_ex( void )
  2070. {
  2071.     UINT32 r,d;
  2072.     PAIR b;
  2073.     EXTWORD(b);
  2074.     d = D;
  2075.     r = d - b.d;
  2076.     CLR_NZVC;
  2077.     SET_FLAGS16(d,b.d,r);
  2078. }
  2079.  
  2080. /* $11b3 CMPU extended -**** */
  2081. INLINE void cmpu_ex( void )
  2082. {
  2083.     UINT32 r,d;
  2084.     PAIR b;
  2085.     EXTWORD(b);
  2086.     d = U;
  2087.     r = d - b.d;
  2088.     CLR_NZVC;
  2089.     SET_FLAGS16(d,b.d,r);
  2090. }
  2091.  
  2092. /* $b4 ANDA extended -**0- */
  2093. INLINE void anda_ex( void )
  2094. {
  2095.     UINT8 t;
  2096.     EXTBYTE(t);
  2097.     A &= t;
  2098.     CLR_NZV;
  2099.     SET_NZ8(A);
  2100. }
  2101.  
  2102. /* $b5 BITA extended -**0- */
  2103. INLINE void bita_ex( void )
  2104. {
  2105.     UINT8 t,r;
  2106.     EXTBYTE(t);
  2107.     r = A & t;
  2108.     CLR_NZV; SET_NZ8(r);
  2109. }
  2110.  
  2111. /* $b6 LDA extended -**0- */
  2112. INLINE void lda_ex( void )
  2113. {
  2114.     EXTBYTE(A);
  2115.     CLR_NZV;
  2116.     SET_NZ8(A);
  2117. }
  2118.  
  2119. /* $b7 STA extended -**0- */
  2120. INLINE void sta_ex( void )
  2121. {
  2122.     CLR_NZV;
  2123.     SET_NZ8(A);
  2124.     EXTENDED;
  2125.     WM(EAD,A);
  2126. }
  2127.  
  2128. /* $b8 EORA extended -**0- */
  2129. INLINE void eora_ex( void )
  2130. {
  2131.     UINT8 t;
  2132.     EXTBYTE(t);
  2133.     A ^= t;
  2134.     CLR_NZV;
  2135.     SET_NZ8(A);
  2136. }
  2137.  
  2138. /* $b9 ADCA extended ***** */
  2139. INLINE void adca_ex( void )
  2140. {
  2141.     UINT16 t,r;
  2142.     EXTBYTE(t);
  2143.     r = A + t + (CC & CC_C);
  2144.     CLR_HNZVC;
  2145.     SET_FLAGS8(A,t,r);
  2146.     SET_H(A,t,r);
  2147.     A = r;
  2148. }
  2149.  
  2150. /* $bA ORA extended -**0- */
  2151. INLINE void ora_ex( void )
  2152. {
  2153.     UINT8 t;
  2154.     EXTBYTE(t);
  2155.     A |= t;
  2156.     CLR_NZV;
  2157.     SET_NZ8(A);
  2158. }
  2159.  
  2160. /* $bB ADDA extended ***** */
  2161. INLINE void adda_ex( void )
  2162. {
  2163.     UINT16 t,r;
  2164.     EXTBYTE(t);
  2165.     r = A + t;
  2166.     CLR_HNZVC;
  2167.     SET_FLAGS8(A,t,r);
  2168.     SET_H(A,t,r);
  2169.     A = r;
  2170. }
  2171.  
  2172. /* $bC CMPX (CMPY CMPS) extended -**** */
  2173. INLINE void cmpx_ex( void )
  2174. {
  2175.     UINT32 r,d;
  2176.     PAIR b;
  2177.     EXTWORD(b);
  2178.     d = X;
  2179.     r = d - b.d;
  2180.     CLR_NZVC;
  2181.     SET_FLAGS16(d,b.d,r);
  2182. }
  2183.  
  2184. /* $10bC CMPY extended -**** */
  2185. INLINE void cmpy_ex( void )
  2186. {
  2187.     UINT32 r,d;
  2188.     PAIR b;
  2189.     EXTWORD(b);
  2190.     d = Y;
  2191.     r = d - b.d;
  2192.     CLR_NZVC;
  2193.     SET_FLAGS16(d,b.d,r);
  2194. }
  2195.  
  2196. /* $11bC CMPS extended -**** */
  2197. INLINE void cmps_ex( void )
  2198. {
  2199.     UINT32 r,d;
  2200.     PAIR b;
  2201.     EXTWORD(b);
  2202.     d = S;
  2203.     r = d - b.d;
  2204.     CLR_NZVC;
  2205.     SET_FLAGS16(d,b.d,r);
  2206. }
  2207.  
  2208. /* $bD JSR extended ----- */
  2209. INLINE void jsr_ex( void )
  2210. {
  2211.     EXTENDED;
  2212.     PUSHWORD(pPC);
  2213.     PCD = EAD;
  2214.     CHANGE_PC;
  2215. }
  2216.  
  2217. /* $bE LDX (LDY) extended -**0- */
  2218. INLINE void ldx_ex( void )
  2219. {
  2220.     EXTWORD(pX);
  2221.     CLR_NZV;
  2222.     SET_NZ16(X);
  2223. }
  2224.  
  2225. /* $10bE LDY extended -**0- */
  2226. INLINE void ldy_ex( void )
  2227. {
  2228.     EXTWORD(pY);
  2229.     CLR_NZV;
  2230.     SET_NZ16(Y);
  2231. }
  2232.  
  2233. /* $bF STX (STY) extended -**0- */
  2234. INLINE void stx_ex( void )
  2235. {
  2236.     CLR_NZV;
  2237.     SET_NZ16(X);
  2238.     EXTENDED;
  2239.     WM16(EAD,&pX);
  2240. }
  2241.  
  2242. /* $10bF STY extended -**0- */
  2243. INLINE void sty_ex( void )
  2244. {
  2245.     CLR_NZV;
  2246.     SET_NZ16(Y);
  2247.     EXTENDED;
  2248.     WM16(EAD,&pY);
  2249. }
  2250.  
  2251.  
  2252. #if macintosh
  2253. #pragma mark ____Cx____
  2254. #endif
  2255.  
  2256. /* $c0 SUBB immediate ?**** */
  2257. INLINE void subb_im( void )
  2258. {
  2259.     UINT16      t,r;
  2260.     IMMBYTE(t);
  2261.     r = B - t;
  2262.     CLR_NZVC;
  2263.     SET_FLAGS8(B,t,r);
  2264.     B = r;
  2265. }
  2266.  
  2267. /* $c1 CMPB immediate ?**** */
  2268. INLINE void cmpb_im( void )
  2269. {
  2270.     UINT16      t,r;
  2271.     IMMBYTE(t);
  2272.     r = B - t;
  2273.     CLR_NZVC; SET_FLAGS8(B,t,r);
  2274. }
  2275.  
  2276. /* $c2 SBCB immediate ?**** */
  2277. INLINE void sbcb_im( void )
  2278. {
  2279.     UINT16      t,r;
  2280.     IMMBYTE(t);
  2281.     r = B - t - (CC & CC_C);
  2282.     CLR_NZVC;
  2283.     SET_FLAGS8(B,t,r);
  2284.     B = r;
  2285. }
  2286.  
  2287. /* $c3 ADDD immediate -**** */
  2288. INLINE void addd_im( void )
  2289. {
  2290.     UINT32 r,d;
  2291.     PAIR b;
  2292.     IMMWORD(b);
  2293.     d = D;
  2294.     r = d + b.d;
  2295.     CLR_NZVC;
  2296.     SET_FLAGS16(d,b.d,r);
  2297.     D = r;
  2298. }
  2299.  
  2300. /* $c4 ANDB immediate -**0- */
  2301. INLINE void andb_im( void )
  2302. {
  2303.     UINT8 t;
  2304.     IMMBYTE(t);
  2305.     B &= t;
  2306.     CLR_NZV;
  2307.     SET_NZ8(B);
  2308. }
  2309.  
  2310. /* $c5 BITB immediate -**0- */
  2311. INLINE void bitb_im( void )
  2312. {
  2313.     UINT8 t,r;
  2314.     IMMBYTE(t);
  2315.     r = B & t;
  2316.     CLR_NZV;
  2317.     SET_NZ8(r);
  2318. }
  2319.  
  2320. /* $c6 LDB immediate -**0- */
  2321. INLINE void ldb_im( void )
  2322. {
  2323.     IMMBYTE(B);
  2324.     CLR_NZV;
  2325.     SET_NZ8(B);
  2326. }
  2327.  
  2328. /* is this a legal instruction? */
  2329. /* $c7 STB immediate -**0- */
  2330. INLINE void stb_im( void )
  2331. {
  2332.     CLR_NZV;
  2333.     SET_NZ8(B);
  2334.     IMM8;
  2335.     WM(EAD,B);
  2336. }
  2337.  
  2338. /* $c8 EORB immediate -**0- */
  2339. INLINE void eorb_im( void )
  2340. {
  2341.     UINT8 t;
  2342.     IMMBYTE(t);
  2343.     B ^= t;
  2344.     CLR_NZV;
  2345.     SET_NZ8(B);
  2346. }
  2347.  
  2348. /* $c9 ADCB immediate ***** */
  2349. INLINE void adcb_im( void )
  2350. {
  2351.     UINT16 t,r;
  2352.     IMMBYTE(t);
  2353.     r = B + t + (CC & CC_C);
  2354.     CLR_HNZVC;
  2355.     SET_FLAGS8(B,t,r);
  2356.     SET_H(B,t,r);
  2357.     B = r;
  2358. }
  2359.  
  2360. /* $cA ORB immediate -**0- */
  2361. INLINE void orb_im( void )
  2362. {
  2363.     UINT8 t;
  2364.     IMMBYTE(t);
  2365.     B |= t;
  2366.     CLR_NZV;
  2367.     SET_NZ8(B);
  2368. }
  2369.  
  2370. /* $cB ADDB immediate ***** */
  2371. INLINE void addb_im( void )
  2372. {
  2373.     UINT16 t,r;
  2374.     IMMBYTE(t);
  2375.     r = B + t;
  2376.     CLR_HNZVC;
  2377.     SET_FLAGS8(B,t,r);
  2378.     SET_H(B,t,r);
  2379.     B = r;
  2380. }
  2381.  
  2382. /* $cC LDD immediate -**0- */
  2383. INLINE void ldd_im( void )
  2384. {
  2385.     IMMWORD(pD);
  2386.     CLR_NZV;
  2387.     SET_NZ16(D);
  2388. }
  2389.  
  2390. /* is this a legal instruction? */
  2391. /* $cD STD immediate -**0- */
  2392. INLINE void std_im( void )
  2393. {
  2394.     CLR_NZV;
  2395.     SET_NZ16(D);
  2396.     IMM16;
  2397.     WM16(EAD,&pD);
  2398. }
  2399.  
  2400. /* $cE LDU (LDS) immediate -**0- */
  2401. INLINE void ldu_im( void )
  2402. {
  2403.     IMMWORD(pU);
  2404.     CLR_NZV;
  2405.     SET_NZ16(U);
  2406. }
  2407.  
  2408. /* $10cE LDS immediate -**0- */
  2409. INLINE void lds_im( void )
  2410. {
  2411.     IMMWORD(pS);
  2412.     CLR_NZV;
  2413.     SET_NZ16(S);
  2414.     m6809.int_state |= M6809_LDS;
  2415. }
  2416.  
  2417. /* is this a legal instruction? */
  2418. /* $cF STU (STS) immediate -**0- */
  2419. INLINE void stu_im( void )
  2420. {
  2421.     CLR_NZV;
  2422.     SET_NZ16(U);
  2423.     IMM16;
  2424.     WM16(EAD,&pU);
  2425. }
  2426.  
  2427. /* is this a legal instruction? */
  2428. /* $10cF STS immediate -**0- */
  2429. INLINE void sts_im( void )
  2430. {
  2431.     CLR_NZV;
  2432.     SET_NZ16(S);
  2433.     IMM16;
  2434.     WM16(EAD,&pS);
  2435. }
  2436.  
  2437.  
  2438. #if macintosh
  2439. #pragma mark ____Dx____
  2440. #endif
  2441.  
  2442. /* $d0 SUBB direct ?**** */
  2443. INLINE void subb_di( void )
  2444. {
  2445.     UINT16      t,r;
  2446.     DIRBYTE(t);
  2447.     r = B - t;
  2448.     CLR_NZVC;
  2449.     SET_FLAGS8(B,t,r);
  2450.     B = r;
  2451. }
  2452.  
  2453. /* $d1 CMPB direct ?**** */
  2454. INLINE void cmpb_di( void )
  2455. {
  2456.     UINT16      t,r;
  2457.     DIRBYTE(t);
  2458.     r = B - t;
  2459.     CLR_NZVC;
  2460.     SET_FLAGS8(B,t,r);
  2461. }
  2462.  
  2463. /* $d2 SBCB direct ?**** */
  2464. INLINE void sbcb_di( void )
  2465. {
  2466.     UINT16      t,r;
  2467.     DIRBYTE(t);
  2468.     r = B - t - (CC & CC_C);
  2469.     CLR_NZVC;
  2470.     SET_FLAGS8(B,t,r);
  2471.     B = r;
  2472. }
  2473.  
  2474. /* $d3 ADDD direct -**** */
  2475. INLINE void addd_di( void )
  2476. {
  2477.     UINT32 r,d;
  2478.     PAIR b;
  2479.     DIRWORD(b);
  2480.     d = D;
  2481.     r = d + b.d;
  2482.     CLR_NZVC;
  2483.     SET_FLAGS16(d,b.d,r);
  2484.     D = r;
  2485. }
  2486.  
  2487. /* $d4 ANDB direct -**0- */
  2488. INLINE void andb_di( void )
  2489. {
  2490.     UINT8 t;
  2491.     DIRBYTE(t);
  2492.     B &= t;
  2493.     CLR_NZV;
  2494.     SET_NZ8(B);
  2495. }
  2496.  
  2497. /* $d5 BITB direct -**0- */
  2498. INLINE void bitb_di( void )
  2499. {
  2500.     UINT8 t,r;
  2501.     DIRBYTE(t);
  2502.     r = B & t;
  2503.     CLR_NZV;
  2504.     SET_NZ8(r);
  2505. }
  2506.  
  2507. /* $d6 LDB direct -**0- */
  2508. INLINE void ldb_di( void )
  2509. {
  2510.     DIRBYTE(B);
  2511.     CLR_NZV;
  2512.     SET_NZ8(B);
  2513. }
  2514.  
  2515. /* $d7 STB direct -**0- */
  2516. INLINE void stb_di( void )
  2517. {
  2518.     CLR_NZV;
  2519.     SET_NZ8(B);
  2520.     DIRECT;
  2521.     WM(EAD,B);
  2522. }
  2523.  
  2524. /* $d8 EORB direct -**0- */
  2525. INLINE void eorb_di( void )
  2526. {
  2527.     UINT8 t;
  2528.     DIRBYTE(t);
  2529.     B ^= t;
  2530.     CLR_NZV;
  2531.     SET_NZ8(B);
  2532. }
  2533.  
  2534. /* $d9 ADCB direct ***** */
  2535. INLINE void adcb_di( void )
  2536. {
  2537.     UINT16 t,r;
  2538.     DIRBYTE(t);
  2539.     r = B + t + (CC & CC_C);
  2540.     CLR_HNZVC;
  2541.     SET_FLAGS8(B,t,r);
  2542.     SET_H(B,t,r);
  2543.     B = r;
  2544. }
  2545.  
  2546. /* $dA ORB direct -**0- */
  2547. INLINE void orb_di( void )
  2548. {
  2549.     UINT8 t;
  2550.     DIRBYTE(t);
  2551.     B |= t;
  2552.     CLR_NZV;
  2553.     SET_NZ8(B);
  2554. }
  2555.  
  2556. /* $dB ADDB direct ***** */
  2557. INLINE void addb_di( void )
  2558. {
  2559.     UINT16 t,r;
  2560.     DIRBYTE(t);
  2561.     r = B + t;
  2562.     CLR_HNZVC;
  2563.     SET_FLAGS8(B,t,r);
  2564.     SET_H(B,t,r);
  2565.     B = r;
  2566. }
  2567.  
  2568. /* $dC LDD direct -**0- */
  2569. INLINE void ldd_di( void )
  2570. {
  2571.     DIRWORD(pD);
  2572.     CLR_NZV;
  2573.     SET_NZ16(D);
  2574. }
  2575.  
  2576. /* $dD STD direct -**0- */
  2577. INLINE void std_di( void )
  2578. {
  2579.     CLR_NZV;
  2580.     SET_NZ16(D);
  2581.     DIRECT;
  2582.     WM16(EAD,&pD);
  2583. }
  2584.  
  2585. /* $dE LDU (LDS) direct -**0- */
  2586. INLINE void ldu_di( void )
  2587. {
  2588.     DIRWORD(pU);
  2589.     CLR_NZV;
  2590.     SET_NZ16(U);
  2591. }
  2592.  
  2593. /* $10dE LDS direct -**0- */
  2594. INLINE void lds_di( void )
  2595. {
  2596.     DIRWORD(pS);
  2597.     CLR_NZV;
  2598.     SET_NZ16(S);
  2599.     m6809.int_state |= M6809_LDS;
  2600. }
  2601.  
  2602. /* $dF STU (STS) direct -**0- */
  2603. INLINE void stu_di( void )
  2604. {
  2605.     CLR_NZV;
  2606.     SET_NZ16(U);
  2607.     DIRECT;
  2608.     WM16(EAD,&pU);
  2609. }
  2610.  
  2611. /* $10dF STS direct -**0- */
  2612. INLINE void sts_di( void )
  2613. {
  2614.     CLR_NZV;
  2615.     SET_NZ16(S);
  2616.     DIRECT;
  2617.     WM16(EAD,&pS);
  2618. }
  2619.  
  2620. #if macintosh
  2621. #pragma mark ____Ex____
  2622. #endif
  2623.  
  2624.  
  2625. /* $e0 SUBB indexed ?**** */
  2626. INLINE void subb_ix( void )
  2627. {
  2628.     UINT16      t,r;
  2629.     fetch_effective_address();
  2630.     t = RM(EAD);
  2631.     r = B - t;
  2632.     CLR_NZVC;
  2633.     SET_FLAGS8(B,t,r);
  2634.     B = r;
  2635. }
  2636.  
  2637. /* $e1 CMPB indexed ?**** */
  2638. INLINE void cmpb_ix( void )
  2639. {
  2640.     UINT16      t,r;
  2641.     fetch_effective_address();
  2642.     t = RM(EAD);
  2643.     r = B - t;
  2644.     CLR_NZVC;
  2645.     SET_FLAGS8(B,t,r);
  2646. }
  2647.  
  2648. /* $e2 SBCB indexed ?**** */
  2649. INLINE void sbcb_ix( void )
  2650. {
  2651.     UINT16      t,r;
  2652.     fetch_effective_address();
  2653.     t = RM(EAD);
  2654.     r = B - t - (CC & CC_C);
  2655.     CLR_NZVC;
  2656.     SET_FLAGS8(B,t,r);
  2657.     B = r;
  2658. }
  2659.  
  2660. /* $e3 ADDD indexed -**** */
  2661. INLINE void addd_ix( void )
  2662. {
  2663.     UINT32 r,d;
  2664.     PAIR b;
  2665.     fetch_effective_address();
  2666.     b.d=RM16(EAD);
  2667.     d = D;
  2668.     r = d + b.d;
  2669.     CLR_NZVC;
  2670.     SET_FLAGS16(d,b.d,r);
  2671.     D = r;
  2672. }
  2673.  
  2674. /* $e4 ANDB indexed -**0- */
  2675. INLINE void andb_ix( void )
  2676. {
  2677.     fetch_effective_address();
  2678.     B &= RM(EAD);
  2679.     CLR_NZV;
  2680.     SET_NZ8(B);
  2681. }
  2682.  
  2683. /* $e5 BITB indexed -**0- */
  2684. INLINE void bitb_ix( void )
  2685. {
  2686.     UINT8 r;
  2687.     fetch_effective_address();
  2688.     r = B & RM(EAD);
  2689.     CLR_NZV;
  2690.     SET_NZ8(r);
  2691. }
  2692.  
  2693. /* $e6 LDB indexed -**0- */
  2694. INLINE void ldb_ix( void )
  2695. {
  2696.     fetch_effective_address();
  2697.     B = RM(EAD);
  2698.     CLR_NZV;
  2699.     SET_NZ8(B);
  2700. }
  2701.  
  2702. /* $e7 STB indexed -**0- */
  2703. INLINE void stb_ix( void )
  2704. {
  2705.     fetch_effective_address();
  2706.     CLR_NZV;
  2707.     SET_NZ8(B);
  2708.     WM(EAD,B);
  2709. }
  2710.  
  2711. /* $e8 EORB indexed -**0- */
  2712. INLINE void eorb_ix( void )
  2713. {
  2714.     fetch_effective_address();
  2715.     B ^= RM(EAD);
  2716.     CLR_NZV;
  2717.     SET_NZ8(B);
  2718. }
  2719.  
  2720. /* $e9 ADCB indexed ***** */
  2721. INLINE void adcb_ix( void )
  2722. {
  2723.     UINT16 t,r;
  2724.     fetch_effective_address();
  2725.     t = RM(EAD);
  2726.     r = B + t + (CC & CC_C);
  2727.     CLR_HNZVC;
  2728.     SET_FLAGS8(B,t,r);
  2729.     SET_H(B,t,r);
  2730.     B = r;
  2731. }
  2732.  
  2733. /* $eA ORB indexed -**0- */
  2734. INLINE void orb_ix( void )
  2735. {
  2736.     fetch_effective_address();
  2737.     B |= RM(EAD);
  2738.     CLR_NZV;
  2739.     SET_NZ8(B);
  2740. }
  2741.  
  2742. /* $eB ADDB indexed ***** */
  2743. INLINE void addb_ix( void )
  2744. {
  2745.     UINT16 t,r;
  2746.     fetch_effective_address();
  2747.     t = RM(EAD);
  2748.     r = B + t;
  2749.     CLR_HNZVC;
  2750.     SET_FLAGS8(B,t,r);
  2751.     SET_H(B,t,r);
  2752.     B = r;
  2753. }
  2754.  
  2755. /* $eC LDD indexed -**0- */
  2756. INLINE void ldd_ix( void )
  2757. {
  2758.     fetch_effective_address();
  2759.     D=RM16(EAD);
  2760.     CLR_NZV; SET_NZ16(D);
  2761. }
  2762.  
  2763. /* $eD STD indexed -**0- */
  2764. INLINE void std_ix( void )
  2765. {
  2766.     fetch_effective_address();
  2767.     CLR_NZV;
  2768.     SET_NZ16(D);
  2769.     WM16(EAD,&pD);
  2770. }
  2771.  
  2772. /* $eE LDU (LDS) indexed -**0- */
  2773. INLINE void ldu_ix( void )
  2774. {
  2775.     fetch_effective_address();
  2776.     U=RM16(EAD);
  2777.     CLR_NZV;
  2778.     SET_NZ16(U);
  2779. }
  2780.  
  2781. /* $10eE LDS indexed -**0- */
  2782. INLINE void lds_ix( void )
  2783. {
  2784.     fetch_effective_address();
  2785.     S=RM16(EAD);
  2786.     CLR_NZV;
  2787.     SET_NZ16(S);
  2788.     m6809.int_state |= M6809_LDS;
  2789. }
  2790.  
  2791. /* $eF STU (STS) indexed -**0- */
  2792. INLINE void stu_ix( void )
  2793. {
  2794.     fetch_effective_address();
  2795.     CLR_NZV;
  2796.     SET_NZ16(U);
  2797.     WM16(EAD,&pU);
  2798. }
  2799.  
  2800. /* $10eF STS indexed -**0- */
  2801. INLINE void sts_ix( void )
  2802. {
  2803.     fetch_effective_address();
  2804.     CLR_NZV;
  2805.     SET_NZ16(S);
  2806.     WM16(EAD,&pS);
  2807. }
  2808.  
  2809. #if macintosh
  2810. #pragma mark ____Fx____
  2811. #endif
  2812.  
  2813. /* $f0 SUBB extended ?**** */
  2814. INLINE void subb_ex( void )
  2815. {
  2816.     UINT16      t,r;
  2817.     EXTBYTE(t);
  2818.     r = B - t;
  2819.     CLR_NZVC;
  2820.     SET_FLAGS8(B,t,r);
  2821.     B = r;
  2822. }
  2823.  
  2824. /* $f1 CMPB extended ?**** */
  2825. INLINE void cmpb_ex( void )
  2826. {
  2827.     UINT16      t,r;
  2828.     EXTBYTE(t);
  2829.     r = B - t;
  2830.     CLR_NZVC;
  2831.     SET_FLAGS8(B,t,r);
  2832. }
  2833.  
  2834. /* $f2 SBCB extended ?**** */
  2835. INLINE void sbcb_ex( void )
  2836. {
  2837.     UINT16      t,r;
  2838.     EXTBYTE(t);
  2839.     r = B - t - (CC & CC_C);
  2840.     CLR_NZVC;
  2841.     SET_FLAGS8(B,t,r);
  2842.     B = r;
  2843. }
  2844.  
  2845. /* $f3 ADDD extended -**** */
  2846. INLINE void addd_ex( void )
  2847. {
  2848.     UINT32 r,d;
  2849.     PAIR b;
  2850.     EXTWORD(b);
  2851.     d = D;
  2852.     r = d + b.d;
  2853.     CLR_NZVC;
  2854.     SET_FLAGS16(d,b.d,r);
  2855.     D = r;
  2856. }
  2857.  
  2858. /* $f4 ANDB extended -**0- */
  2859. INLINE void andb_ex( void )
  2860. {
  2861.     UINT8 t;
  2862.     EXTBYTE(t);
  2863.     B &= t;
  2864.     CLR_NZV;
  2865.     SET_NZ8(B);
  2866. }
  2867.  
  2868. /* $f5 BITB extended -**0- */
  2869. INLINE void bitb_ex( void )
  2870. {
  2871.     UINT8 t,r;
  2872.     EXTBYTE(t);
  2873.     r = B & t;
  2874.     CLR_NZV;
  2875.     SET_NZ8(r);
  2876. }
  2877.  
  2878. /* $f6 LDB extended -**0- */
  2879. INLINE void ldb_ex( void )
  2880. {
  2881.     EXTBYTE(B);
  2882.     CLR_NZV;
  2883.     SET_NZ8(B);
  2884. }
  2885.  
  2886. /* $f7 STB extended -**0- */
  2887. INLINE void stb_ex( void )
  2888. {
  2889.     CLR_NZV;
  2890.     SET_NZ8(B);
  2891.     EXTENDED;
  2892.     WM(EAD,B);
  2893. }
  2894.  
  2895. /* $f8 EORB extended -**0- */
  2896. INLINE void eorb_ex( void )
  2897. {
  2898.     UINT8 t;
  2899.     EXTBYTE(t);
  2900.     B ^= t;
  2901.     CLR_NZV;
  2902.     SET_NZ8(B);
  2903. }
  2904.  
  2905. /* $f9 ADCB extended ***** */
  2906. INLINE void adcb_ex( void )
  2907. {
  2908.     UINT16 t,r;
  2909.     EXTBYTE(t);
  2910.     r = B + t + (CC & CC_C);
  2911.     CLR_HNZVC;
  2912.     SET_FLAGS8(B,t,r);
  2913.     SET_H(B,t,r);
  2914.     B = r;
  2915. }
  2916.  
  2917. /* $fA ORB extended -**0- */
  2918. INLINE void orb_ex( void )
  2919. {
  2920.     UINT8 t;
  2921.     EXTBYTE(t);
  2922.     B |= t;
  2923.     CLR_NZV;
  2924.     SET_NZ8(B);
  2925. }
  2926.  
  2927. /* $fB ADDB extended ***** */
  2928. INLINE void addb_ex( void )
  2929. {
  2930.     UINT16 t,r;
  2931.     EXTBYTE(t);
  2932.     r = B + t;
  2933.     CLR_HNZVC;
  2934.     SET_FLAGS8(B,t,r);
  2935.     SET_H(B,t,r);
  2936.     B = r;
  2937. }
  2938.  
  2939. /* $fC LDD extended -**0- */
  2940. INLINE void ldd_ex( void )
  2941. {
  2942.     EXTWORD(pD);
  2943.     CLR_NZV;
  2944.     SET_NZ16(D);
  2945. }
  2946.  
  2947. /* $fD STD extended -**0- */
  2948. INLINE void std_ex( void )
  2949. {
  2950.     CLR_NZV;
  2951.     SET_NZ16(D);
  2952.     EXTENDED;
  2953.     WM16(EAD,&pD);
  2954. }
  2955.  
  2956. /* $fE LDU (LDS) extended -**0- */
  2957. INLINE void ldu_ex( void )
  2958. {
  2959.     EXTWORD(pU);
  2960.     CLR_NZV;
  2961.     SET_NZ16(U);
  2962. }
  2963.  
  2964. /* $10fE LDS extended -**0- */
  2965. INLINE void lds_ex( void )
  2966. {
  2967.     EXTWORD(pS);
  2968.     CLR_NZV;
  2969.     SET_NZ16(S);
  2970.     m6809.int_state |= M6809_LDS;
  2971. }
  2972.  
  2973. /* $fF STU (STS) extended -**0- */
  2974. INLINE void stu_ex( void )
  2975. {
  2976.     CLR_NZV;
  2977.     SET_NZ16(U);
  2978.     EXTENDED;
  2979.     WM16(EAD,&pU);
  2980. }
  2981.  
  2982. /* $10fF STS extended -**0- */
  2983. INLINE void sts_ex( void )
  2984. {
  2985.     CLR_NZV;
  2986.     SET_NZ16(S);
  2987.     EXTENDED;
  2988.     WM16(EAD,&pS);
  2989. }
  2990.  
  2991. /* $10xx opcodes */
  2992. INLINE void pref10( void )
  2993. {
  2994.     UINT8 ireg2 = ROP(PCD);
  2995.     PC++;
  2996.     switch( ireg2 )
  2997.     {
  2998.         case 0x21: lbrn();        m6809_ICount-=5;    break;
  2999.         case 0x22: lbhi();        m6809_ICount-=5;    break;
  3000.         case 0x23: lbls();        m6809_ICount-=5;    break;
  3001.         case 0x24: lbcc();        m6809_ICount-=5;    break;
  3002.         case 0x25: lbcs();        m6809_ICount-=5;    break;
  3003.         case 0x26: lbne();        m6809_ICount-=5;    break;
  3004.         case 0x27: lbeq();        m6809_ICount-=5;    break;
  3005.         case 0x28: lbvc();        m6809_ICount-=5;    break;
  3006.         case 0x29: lbvs();        m6809_ICount-=5;    break;
  3007.         case 0x2a: lbpl();        m6809_ICount-=5;    break;
  3008.         case 0x2b: lbmi();        m6809_ICount-=5;    break;
  3009.         case 0x2c: lbge();        m6809_ICount-=5;    break;
  3010.         case 0x2d: lblt();        m6809_ICount-=5;    break;
  3011.         case 0x2e: lbgt();        m6809_ICount-=5;    break;
  3012.         case 0x2f: lble();        m6809_ICount-=5;    break;
  3013.  
  3014.         case 0x3f: swi2();        m6809_ICount-=20;    break;
  3015.  
  3016.         case 0x83: cmpd_im();    m6809_ICount-=5;    break;
  3017.         case 0x8c: cmpy_im();    m6809_ICount-=5;    break;
  3018.         case 0x8e: ldy_im();    m6809_ICount-=4;    break;
  3019.         case 0x8f: sty_im();    m6809_ICount-=4;    break;
  3020.  
  3021.         case 0x93: cmpd_di();    m6809_ICount-=7;    break;
  3022.         case 0x9c: cmpy_di();    m6809_ICount-=7;    break;
  3023.         case 0x9e: ldy_di();    m6809_ICount-=6;    break;
  3024.         case 0x9f: sty_di();    m6809_ICount-=6;    break;
  3025.  
  3026.         case 0xa3: cmpd_ix();    m6809_ICount-=7;    break;
  3027.         case 0xac: cmpy_ix();    m6809_ICount-=7;    break;
  3028.         case 0xae: ldy_ix();    m6809_ICount-=6;    break;
  3029.         case 0xaf: sty_ix();    m6809_ICount-=6;    break;
  3030.  
  3031.         case 0xb3: cmpd_ex();    m6809_ICount-=8;    break;
  3032.         case 0xbc: cmpy_ex();    m6809_ICount-=8;    break;
  3033.         case 0xbe: ldy_ex();    m6809_ICount-=7;    break;
  3034.         case 0xbf: sty_ex();    m6809_ICount-=7;    break;
  3035.  
  3036.         case 0xce: lds_im();    m6809_ICount-=4;    break;
  3037.         case 0xcf: sts_im();    m6809_ICount-=4;    break;
  3038.  
  3039.         case 0xde: lds_di();    m6809_ICount-=4;    break;
  3040.         case 0xdf: sts_di();    m6809_ICount-=4;    break;
  3041.  
  3042.         case 0xee: lds_ix();    m6809_ICount-=6;    break;
  3043.         case 0xef: sts_ix();    m6809_ICount-=6;    break;
  3044.  
  3045.         case 0xfe: lds_ex();    m6809_ICount-=7;    break;
  3046.         case 0xff: sts_ex();    m6809_ICount-=7;    break;
  3047.  
  3048.         default:   illegal();                        break;
  3049.     }
  3050. }
  3051.  
  3052. /* $11xx opcodes */
  3053. INLINE void pref11( void )
  3054. {
  3055.     UINT8 ireg2 = ROP(PCD);
  3056.     PC++;
  3057.     switch( ireg2 )
  3058.     {
  3059.         case 0x3f: swi3();        m6809_ICount-=20;    break;
  3060.  
  3061.         case 0x83: cmpu_im();    m6809_ICount-=5;    break;
  3062.         case 0x8c: cmps_im();    m6809_ICount-=5;    break;
  3063.  
  3064.         case 0x93: cmpu_di();    m6809_ICount-=7;    break;
  3065.         case 0x9c: cmps_di();    m6809_ICount-=7;    break;
  3066.  
  3067.         case 0xa3: cmpu_ix();    m6809_ICount-=7;    break;
  3068.         case 0xac: cmps_ix();    m6809_ICount-=7;    break;
  3069.  
  3070.         case 0xb3: cmpu_ex();    m6809_ICount-=8;    break;
  3071.         case 0xbc: cmps_ex();    m6809_ICount-=8;    break;
  3072.  
  3073.         default:   illegal();                        break;
  3074.     }
  3075. }
  3076.  
  3077.  
  3078.